X-Git-Url: http://code.vuplus.com/gitweb/?p=vuplus_dvbapp;a=blobdiff_plain;f=lib%2Fpython%2FScreens%2FScanSetup.py;h=6fdeb534da524398fca58864aea04fda29eed12a;hp=5d0495450314a140153e252629798474f1b91b4c;hb=5219d43296787b3592eedba7fd78b54e87638351;hpb=c6d6a6bf299db0314a444258dcde7716c580dba2 diff --git a/lib/python/Screens/ScanSetup.py b/lib/python/Screens/ScanSetup.py index 5d04954..6fdeb53 100644 --- a/lib/python/Screens/ScanSetup.py +++ b/lib/python/Screens/ScanSetup.py @@ -8,6 +8,7 @@ from Components.ConfigList import ConfigListScreen from Components.NimManager import nimmanager, getConfigSatlist from Components.Label import Label from Tools.Directories import resolveFilename, SCOPE_DEFAULTPARTITIONMOUNTDIR, SCOPE_DEFAULTDIR, SCOPE_DEFAULTPARTITION +from Tools.HardwareInfo import HardwareInfo from Screens.MessageBox import MessageBox from enigma import eTimer, eDVBFrontendParametersSatellite, eComponentScan, \ eDVBSatelliteEquipmentControl, eDVBFrontendParametersTerrestrial, \ @@ -16,65 +17,20 @@ from enigma import eTimer, eDVBFrontendParametersSatellite, eComponentScan, \ def buildTerTransponder(frequency, inversion=2, bandwidth = 3, fechigh = 6, feclow = 6, modulation = 2, transmission = 2, guard = 4, - hierarchy = 4): - + hierarchy = 4, system = 0, plpid = 0): # print "freq", frequency, "inv", inversion, "bw", bandwidth, "fech", fechigh, "fecl", feclow, "mod", modulation, "tm", transmission, "guard", guard, "hierarchy", hierarchy - - # WARNING: normally, enums are working directly. - # Don't copy this (very bad)!! Instead either fix swig (good) or - # move this into a central place. - Bw8MHz = 0 - Bw7MHz = 1 - Bw6MHz = 2 - #Bw5MHz = 3 #not implemented for e1 compatibilty - BwAuto = 3 - - f1_2 = 0 - f2_3 = 1 - f3_4 = 2 - f5_6 = 3 - f7_8 = 4 - fAuto = 5 - - TM2k = 0 - TM8k = 1 - #TM4k = 2 #not implemented for e1 compatibilty - TMAuto = 2 - - GI_1_32 = 0 - GI_1_16 = 1 - GI_1_8 = 2 - GI_1_4 = 3 - GI_Auto = 4 - - HNone = 0 - H1 = 1 - H2 = 2 - H4 = 3 - HAuto = 4 - - QPSK = 0 - QAM16 = 1 - QAM64 = 2 - Auto = 3 - - Off = 0 - On = 1 - Unknown = 2 - parm = eDVBFrontendParametersTerrestrial() - parm.frequency = frequency - - parm.inversion = [Off, On, Unknown][inversion] - parm.bandwidth = [Bw8MHz, Bw7MHz, Bw6MHz, BwAuto][bandwidth] # Bw5MHz unsupported - parm.code_rate_HP = [f1_2, f2_3, f3_4, f5_6, f7_8, fAuto][fechigh] - parm.code_rate_LP = [f1_2, f2_3, f3_4, f5_6, f7_8, fAuto][feclow] - parm.modulation = [QPSK, QAM16, QAM64, Auto][modulation] - parm.transmission_mode = [TM2k, TM8k, TMAuto][transmission] # TM4k unsupported - parm.guard_interval = [GI_1_32, GI_1_16, GI_1_8, GI_1_4, GI_Auto][guard] - parm.hierarchy = [HNone, H1, H2, H4, HAuto][hierarchy] - + parm.inversion = inversion + parm.bandwidth = bandwidth + parm.code_rate_HP = fechigh + parm.code_rate_LP = feclow + parm.modulation = modulation + parm.transmission_mode = transmission + parm.guard_interval = guard + parm.hierarchy = hierarchy + parm.system = system + parm.plpid = plpid return parm def getInitialTransponderList(tlist, pos): @@ -103,7 +59,7 @@ def getInitialCableTransponderList(tlist, nim): parm.symbol_rate = x[2] parm.modulation = x[3] parm.fec_inner = x[4] - parm.inversion = 2 # AUTO + parm.inversion = parm.Inversion_Unknown #print "frequency:", x[1] #print "symbol_rate:", x[2] #print "modulation:", x[3] @@ -111,17 +67,20 @@ def getInitialCableTransponderList(tlist, nim): #print "inversion:", 2 tlist.append(parm) -def getInitialTerrestrialTransponderList(tlist, region): +def getInitialTerrestrialTransponderList(tlist, region, skip_t2 = False): list = nimmanager.getTranspondersTerrestrial(region) - #self.transponders[self.parsedTer].append((2,freq,bw,const,crh,crl,guard,transm,hierarchy,inv)) + #self.transponders[self.parsedTer].append((2,freq,bw,const,crh,crl,guard,transm,hierarchy,inv,system,plpid)) #def buildTerTransponder(frequency, inversion = 2, bandwidth = 3, fechigh = 6, feclow = 6, - #modulation = 2, transmission = 2, guard = 4, hierarchy = 4): + #modulation = 2, transmission = 2, guard = 4, hierarchy = 4, system = 0, plpid = 0):): for x in list: if x[0] == 2: #TERRESTRIAL - parm = buildTerTransponder(x[1], x[9], x[2], x[4], x[5], x[3], x[7], x[6], x[8]) + if skip_t2 and x[10] == eDVBFrontendParametersTerrestrial.System_DVB_T2: + # Should be searching on TerrestrialTransponderSearchSupport. + continue + parm = buildTerTransponder(x[1], x[9], x[2], x[4], x[5], x[3], x[7], x[6], x[8], x[10], x[11]) tlist.append(parm) cable_bands = { @@ -139,6 +98,34 @@ cable_bands = { "DVBC_BAND_US_HYPER" : 1 << 11, } +cable_autoscan_nimtype = { +'SSH108' : 'ssh108', +'TT3L10' : 'tt3l10', +'TURBO' : 'vuplus_turbo_c' +} + +terrestrial_autoscan_nimtype = { +'SSH108' : 'ssh108_t2_scan', +'TT3L10' : 'tt3l10_t2_scan', +'TURBO' : 'vuplus_turbo_t' +} + +def GetDeviceId(filter, nim_idx): + tuners={} + device_id = 0 + socket_id = 0 + for nim in nimmanager.nim_slots: + name_token = nim.description.split(' ') + name = name_token[-1][4:-1] + if name == filter: + if socket_id == nim_idx: + break + + if device_id: device_id = 0 + else: device_id = 1 + socket_id += 1 + return device_id + class CableTransponderSearchSupport: # def setCableTransponderSearchResult(self, tlist): # pass @@ -153,6 +140,7 @@ class CableTransponderSearchSupport: if raw_channel: frontend = raw_channel.getFrontend() if frontend: + frontend.closeFrontend() # immediate close... del frontend del raw_channel return True @@ -160,12 +148,16 @@ class CableTransponderSearchSupport: def cableTransponderSearchSessionClosed(self, *val): print "cableTransponderSearchSessionClosed, val", val - self.cable_search_container.appClosed.get().remove(self.cableTransponderSearchClosed) - self.cable_search_container.dataAvail.get().remove(self.getCableTransponderData) + self.cable_search_container.appClosed.remove(self.cableTransponderSearchClosed) + self.cable_search_container.dataAvail.remove(self.getCableTransponderData) + if val and len(val): + if val[0]: + self.setCableTransponderSearchResult(self.__tlist) + else: + self.cable_search_container.sendCtrlC() + self.setCableTransponderSearchResult(None) self.cable_search_container = None self.cable_search_session = None - if val and len(val) and val[0]: - self.setCableTransponderSearchResult(self.__tlist) self.__tlist = None self.cableTransponderSearchFinished() @@ -178,24 +170,58 @@ class CableTransponderSearchSupport: if len(data): if data[0] == 'OK': print str - qam = { "QAM16" : 1, "QAM32" : 2, "QAM64" : 3, "QAM128" : 4, "QAM256" : 5 } - inv = { "INVERSION_OFF" : 0, "INVERSION_ON" : 1 } - fec = { "FEC_AUTO" : 0, "FEC_1_2" : 1, "FEC_2_3" : 2, "FEC_3_4" : 3, "FEC_5_6": 4, "FEC_7_8" : 5, "FEC_8_9" : 6, "FEC_NONE" : 15 } parm = eDVBFrontendParametersCable() + qam = { "QAM16" : parm.Modulation_QAM16, + "QAM32" : parm.Modulation_QAM32, + "QAM64" : parm.Modulation_QAM64, + "QAM128" : parm.Modulation_QAM128, + "QAM256" : parm.Modulation_QAM256 } + inv = { "INVERSION_OFF" : parm.Inversion_Off, + "INVERSION_ON" : parm.Inversion_On, + "INVERSION_AUTO" : parm.Inversion_Unknown } + fec = { "FEC_AUTO" : parm.FEC_Auto, + "FEC_1_2" : parm.FEC_1_2, + "FEC_2_3" : parm.FEC_2_3, + "FEC_3_4" : parm.FEC_3_4, + "FEC_5_6": parm.FEC_5_6, + "FEC_7_8" : parm.FEC_7_8, + "FEC_8_9" : parm.FEC_8_9, + "FEC_NONE" : parm.FEC_None } parm.frequency = int(data[1]) parm.symbol_rate = int(data[2]) parm.fec_inner = fec[data[3]] parm.modulation = qam[data[4]] parm.inversion = inv[data[5]] self.__tlist.append(parm) - tmpstr = _("Try to find used Transponders in cable network.. please wait...") - tmpstr += "\n\n" - tmpstr += data[1] - tmpstr += " kHz " - tmpstr += data[0] - self.cable_search_session["text"].setText(tmpstr) + tmpstr = _("Try to find used Transponders in cable network.. please wait...") + tmpstr += "\n\n" + tmpstr += data[1] + tmpstr += " kHz " + tmpstr += data[0] + self.cable_search_session["text"].setText(tmpstr) def startCableTransponderSearch(self, nim_idx): + def GetCommand(nim_idx): + global cable_autoscan_nimtype + try: + nim_name = nimmanager.getNimName(nim_idx) + if nim_name is not None and nim_name != "": + device_id = "" + nim_name = nim_name.split(' ')[-1][4:-1] + if nim_name == 'TT3L10': + try: + device_id = GetDeviceId('TT3L10', nim_idx) + device_id = "--device=%s" % (device_id) + except Exception, err: + print "GetCommand ->", err + device_id = "--device=0" +# print nim_idx, nim_name, cable_autoscan_nimtype[nim_name], device_id + command = "%s %s" % (cable_autoscan_nimtype[nim_name], device_id) + return command + except Exception, err: + print "GetCommand ->", err + return "tda1002x" + if not self.tryGetRawFrontend(nim_idx): self.session.nav.stopService() if not self.tryGetRawFrontend(nim_idx): @@ -207,18 +233,21 @@ class CableTransponderSearchSupport: return self.__tlist = [ ] self.cable_search_container = eConsoleAppContainer() - self.cable_search_container.appClosed.get().append(self.cableTransponderSearchClosed) - self.cable_search_container.dataAvail.get().append(self.getCableTransponderData) + self.cable_search_container.appClosed.append(self.cableTransponderSearchClosed) + self.cable_search_container.dataAvail.append(self.getCableTransponderData) cableConfig = config.Nims[nim_idx].cable - cmd = "tda1002x --init --scan --verbose --wakeup --inv 2 --bus " - #FIXMEEEEEE hardcoded i2c devices for dm7025 and dm8000 - if nim_idx < 2: - cmd += str(nim_idx) + tunername = nimmanager.getNimName(nim_idx) + bus = nimmanager.getI2CDevice(nim_idx) + if bus is None: + print "ERROR: could not get I2C device for nim", nim_idx, "for cable transponder search" + bus = 2 + + if tunername == "CXD1981": + cmd = "cxd1978 --init --scan --verbose --wakeup --inv 2 --bus %d" % bus else: - if nim_idx == 2: - cmd += "2" # first nim socket on DM8000 use /dev/i2c/2 - else: - cmd += "4" # second nim socket on DM8000 use /dev/i2c/4 + bin_name = GetCommand(nim_idx) + cmd = "%(BIN_NAME)s --init --scan --verbose --wakeup --inv 2 --bus %(BUS)d" % {'BIN_NAME':bin_name , 'BUS':bus} + if cableConfig.scan_type.value == "bands": cmd += " --scan-bands " bands = 0 @@ -272,15 +301,198 @@ class CableTransponderSearchSupport: cmd += " --sr " cmd += str(cableConfig.scan_sr_ext2.value) cmd += "000" - print "TDA1002x CMD is", cmd + print bin_name, " CMD is", cmd self.cable_search_container.execute(cmd) tmpstr = _("Try to find used transponders in cable network.. please wait...") tmpstr += "\n\n..." self.cable_search_session = self.session.openWithCallback(self.cableTransponderSearchSessionClosed, MessageBox, tmpstr, MessageBox.TYPE_INFO) +class TerrestrialTransponderSearchSupport: +# def setTerrestrialTransponderSearchResult(self, tlist): +# pass + +# def terrestrialTransponderSearchFinished(self): +# pass + + def terrestrialTransponderSearchSessionClosed(self, *val): + print "TerrestrialTransponderSearchSessionClosed, val", val + self.terrestrial_search_container.appClosed.remove(self.terrestrialTransponderSearchClosed) + self.terrestrial_search_container.dataAvail.remove(self.getTerrestrialTransponderData) + if val and len(val): + if val[0]: + self.setTerrestrialTransponderSearchResult(self.__tlist) + else: + self.terrestrial_search_container.sendCtrlC() + self.setTerrestrialTransponderSearchResult(None) + self.terrestrial_search_container = None + self.terrestrial_search_session = None + self.__tlist = None + self.terrestrialTransponderSearchFinished() + + def terrestrialTransponderSearchClosed(self, retval): + self.setTerrestrialTransponderData() + opt = self.terrestrialTransponderGetOpt() + if opt is None: + print "terrestrialTransponderSearch finished", retval + self.terrestrial_search_session.close(True) + else: + (freq, bandWidth) = opt + self.terrestrialTransponderSearch(freq, bandWidth) + + def getTerrestrialTransponderData(self, str): + self.terrestrial_search_data += str + + def setTerrestrialTransponderData(self): + print self.terrestrial_search_data + data = self.terrestrial_search_data.split() + if len(data): +# print "[setTerrestrialTransponderData] data : ", data + if data[0] == 'OK': + # DVB-T : OK frequency bandwidth delivery system -1 + # DVB-T2 : OK frequency bandwidth delivery system number_of_plp plp_id0:plp_type0 + if data[3] == 1: # DVB-T + parm = eDVBFrontendParametersTerrestrial() + parm.frequency = int(data[1]) + parm.bandwidth = int(data[2]) + parm.inversion = parm.Inversion_Unknown + parm.code_rate_HP = parm.FEC_Auto + parm.code_rate_LP = parm.FEC_Auto + parm.modulation = parm.Modulation_Auto + parm.transmission_mode = parm.TransmissionMode_Auto + parm.guard_interval = parm.GuardInterval_Auto + parm.hierarchy = parm.Hierarchy_Auto + parm.system = parm.System_DVB_T + parm.plpid = 0 + self.__tlist.append(parm) + else: + plp_list = data[5:] + plp_num = int(data[4]) + if len(plp_list) > plp_num: + plp_list = plp_list[:plp_num] + for plp in plp_list: + (plp_id, plp_type) = plp.split(':') + if plp_type == '0': # common PLP: + continue + parm = eDVBFrontendParametersTerrestrial() + parm.frequency = int(data[1]) + parm.bandwidth = self.terrestrialTransponderconvBandwidth_P(int(data[2])) + parm.inversion = parm.Inversion_Unknown + parm.code_rate_HP = parm.FEC_Auto + parm.code_rate_LP = parm.FEC_Auto + parm.modulation = parm.Modulation_Auto + parm.transmission_mode = parm.TransmissionMode_Auto + parm.guard_interval = parm.GuardInterval_Auto + parm.hierarchy = parm.Hierarchy_Auto + parm.system = parm.System_DVB_T2 + parm.plpid = int(plp_id) + self.__tlist.append(parm) + + tmpstr = _("Try to find used Transponders in terrestrial network.. please wait...") + tmpstr += "\n\n" + tmpstr += data[1][:-3] + tmpstr += " kHz " + tmpstr += data[0] + self.terrestrial_search_session["text"].setText(tmpstr) + + def terrestrialTransponderInitSearchList(self, searchList, region): + tpList = nimmanager.getTranspondersTerrestrial(region) + for x in tpList: + if x[0] == 2: #TERRESTRIAL + freq = x[1] # frequency + bandWidth = self.terrestrialTransponderConvBandwidth_I(x[2]) # bandWidth + parm = (freq, bandWidth) + searchList.append(parm) + + def terrestrialTransponderConvBandwidth_I(self, _bandWidth): + bandWidth = { + eDVBFrontendParametersTerrestrial.Bandwidth_8MHz : 8000000, + eDVBFrontendParametersTerrestrial.Bandwidth_7MHz : 7000000, + eDVBFrontendParametersTerrestrial.Bandwidth_6MHz : 6000000, + eDVBFrontendParametersTerrestrial.Bandwidth_5MHz : 5000000, + eDVBFrontendParametersTerrestrial.Bandwidth_1_712MHz : 1712000, + eDVBFrontendParametersTerrestrial.Bandwidth_10MHz : 10000000, + }.get(_bandWidth, 8000000) + return bandWidth + + def terrestrialTransponderconvBandwidth_P(self, _bandWidth): + bandWidth = { + 8000000 : eDVBFrontendParametersTerrestrial.Bandwidth_8MHz, + 7000000 : eDVBFrontendParametersTerrestrial.Bandwidth_7MHz, + 6000000 : eDVBFrontendParametersTerrestrial.Bandwidth_6MHz, + 5000000 : eDVBFrontendParametersTerrestrial.Bandwidth_5MHz, + 1712000 : eDVBFrontendParametersTerrestrial.Bandwidth_1_712MHz, + 10000000 : eDVBFrontendParametersTerrestrial.Bandwidth_10MHz, + }.get(_bandWidth, eDVBFrontendParametersTerrestrial.Bandwidth_8MHz) + return bandWidth + + def terrestrialTransponderGetOpt(self): + if len(self.terrestrial_search_list) > 0: + return self.terrestrial_search_list.pop(0) + else: + return None + + def terrestrialTransponderGetCmd(self, nim_idx): + global terrestrial_autoscan_nimtype + try: + nim_name = nimmanager.getNimName(nim_idx) + if nim_name is not None and nim_name != "": + device_id = "" + nim_name = nim_name.split(' ')[-1][4:-1] + if nim_name == 'TT3L10': + try: + device_id = GetDeviceId('TT3L10', nim_idx) + device_id = "--device %s" % (device_id) + except Exception, err: + print "terrestrialTransponderGetCmd ->", err + device_id = "--device 0" +# print nim_idx, nim_name, terrestrial_autoscan_nimtype[nim_name], device_id + command = "%s %s" % (terrestrial_autoscan_nimtype[nim_name], device_id) + return command + except Exception, err: + print "terrestrialTransponderGetCmd ->", err + return "" + + def startTerrestrialTransponderSearch(self, nim_idx, region): + if not self.tryGetRawFrontend(nim_idx): + self.session.nav.stopService() + if not self.tryGetRawFrontend(nim_idx): + if self.session.pipshown: # try to disable pip + self.session.pipshown = False + del self.session.pip + if not self.tryGetRawFrontend(nim_idx): + self.terrestrialTransponderSearchFinished() + return + self.__tlist = [ ] + self.terrestrial_search_container = eConsoleAppContainer() + self.terrestrial_search_container.appClosed.append(self.terrestrialTransponderSearchClosed) + self.terrestrial_search_container.dataAvail.append(self.getTerrestrialTransponderData) + + self.terrestrial_search_binName = self.terrestrialTransponderGetCmd(nim_idx) + + self.terrestrial_search_bus = nimmanager.getI2CDevice(nim_idx) + if self.terrestrial_search_bus is None: +# print "ERROR: could not get I2C device for nim", nim_idx, "for terrestrial transponder search" + self.terrestrial_search_bus = 2 + + self.terrestrial_search_list = [] + self.terrestrialTransponderInitSearchList(self.terrestrial_search_list ,region) + (freq, bandWidth) = self.terrestrialTransponderGetOpt() + self.terrestrialTransponderSearch(freq, bandWidth) + + tmpstr = _("Try to find used transponders in terrestrial network.. please wait...") + tmpstr += "\n\n..." + self.terrestrial_search_session = self.session.openWithCallback(self.terrestrialTransponderSearchSessionClosed, MessageBox, tmpstr, MessageBox.TYPE_INFO) + + def terrestrialTransponderSearch(self, freq, bandWidth): + self.terrestrial_search_data = "" + cmd = "%s --freq %d --bw %d --bus %d --ds 2" % (self.terrestrial_search_binName, freq, bandWidth, self.terrestrial_search_bus) + print "SCAN CMD : ",cmd + self.terrestrial_search_container.execute(cmd) + class DefaultSatLists(DefaultWizard): def __init__(self, session, silent = True, showSteps = False): + self.xmlfile = "defaultsatlists.xml" DefaultWizard.__init__(self, session, silent, showSteps, neededTag = "services") print "configuredSats:", nimmanager.getConfiguredSats() @@ -290,17 +502,16 @@ class DefaultSatLists(DefaultWizard): import os os.system("mount %s %s" % (resolveFilename(SCOPE_DEFAULTPARTITION), resolveFilename(SCOPE_DEFAULTPARTITIONMOUNTDIR))) self.directory.append(resolveFilename(SCOPE_DEFAULTPARTITIONMOUNTDIR)) - self.xmlfile = "defaultsatlists.xml" - + def statusCallback(self, status, progress): print "statusCallback:", status, progress from Components.DreamInfoHandler import DreamInfoHandler if status == DreamInfoHandler.STATUS_DONE: - self["text"].setText(_("The installation of the default services lists is finished.")) + self["text"].setText(_("The installation of the default services lists is finished.") + "\n\n" + _("Please press OK to continue.")) self.markDone() self.disableKeys = False -class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport): +class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport, TerrestrialTransponderSearchSupport): def __init__(self, session): Screen.__init__(self, session) @@ -330,9 +541,11 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport): self.list = [] ConfigListScreen.__init__(self, self.list) - self.createSetup() - - self["introduction"] = Label(_("Press OK to start the scan")) + if not self.scan_nims.value == "": + self.createSetup() + self["introduction"] = Label(_("Press OK to start the scan")) + else: + self["introduction"] = Label(_("Nothing to scan!\nPlease setup your tuner settings before you start a service scan.")) def runAsync(self, finished_cb): self.finished_cb = finished_cb @@ -372,6 +585,7 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport): self.typeOfScanEntry = getConfigListEntry(_("Type of scan"), self.scan_typeterrestrial) self.list.append(self.typeOfScanEntry) + self.scan_networkScan.value = False if nim.isCompatible("DVB-S"): if self.scan_type.value == "single_transponder": self.updateSatList() @@ -380,80 +594,74 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport): self.list.append(self.systemEntry) else: # downgrade to dvb-s, in case a -s2 config was active - self.scan_sat.system.value = "dvb-s" + self.scan_sat.system.value = eDVBFrontendParametersSatellite.System_DVB_S self.list.append(getConfigListEntry(_('Satellite'), self.scan_satselection[index_to_scan])) self.list.append(getConfigListEntry(_('Frequency'), self.scan_sat.frequency)) self.list.append(getConfigListEntry(_('Inversion'), self.scan_sat.inversion)) - self.list.append(getConfigListEntry(_('Symbol Rate'), self.scan_sat.symbolrate)) - self.list.append(getConfigListEntry(_("Polarity"), self.scan_sat.polarization)) - if self.scan_sat.system.value == "dvb-s": + self.list.append(getConfigListEntry(_('Symbol rate'), self.scan_sat.symbolrate)) + self.list.append(getConfigListEntry(_('Polarization'), self.scan_sat.polarization)) + if self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S: self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec)) - elif self.scan_sat.system.value == "dvb-s2": + elif self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S2: self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2)) self.modulationEntry = getConfigListEntry(_('Modulation'), self.scan_sat.modulation) self.list.append(self.modulationEntry) - self.list.append(getConfigListEntry(_('Rolloff'), self.scan_sat.rolloff)) - if self.scan_sat.modulation.value == "8psk": - self.list.append(getConfigListEntry(_('Pilot'), self.scan_sat.pilot)) - self.list.append(getConfigListEntry(_("Network scan"), self.scan_networkScan)) + self.list.append(getConfigListEntry(_('Roll-off'), self.scan_sat.rolloff)) + self.list.append(getConfigListEntry(_('Pilot'), self.scan_sat.pilot)) elif self.scan_type.value == "single_satellite": self.updateSatList() print self.scan_satselection[index_to_scan] self.list.append(getConfigListEntry(_("Satellite"), self.scan_satselection[index_to_scan])) - self.list.append(getConfigListEntry(_("Clear before scan"), self.scan_clearallservices)) - elif self.scan_type.value == "multisat": - # if (norotor) + self.scan_networkScan.value = True + elif self.scan_type.value.find("multisat") != -1: tlist = [] SatList = nimmanager.getSatListForNim(index_to_scan) - self.list.append(getConfigListEntry(_("Clear before scan"), self.scan_clearallservices)) for x in SatList: if self.Satexists(tlist, x[0]) == 0: tlist.append(x[0]) - sat = ConfigEnableDisable(default = True) + sat = ConfigEnableDisable(default = self.scan_type.value.find("_yes") != -1 and True or False) configEntry = getConfigListEntry(nimmanager.getSatDescription(x[0]), sat) self.list.append(configEntry) self.multiscanlist.append((x[0], sat)) - # if (rotor): - # for sat in nimmanager.satList: - # self.list.append(getConfigListEntry(sat[1], self.scan_scansat[sat[0]])) + self.scan_networkScan.value = True elif nim.isCompatible("DVB-C"): if self.scan_typecable.value == "single_transponder": self.list.append(getConfigListEntry(_("Frequency"), self.scan_cab.frequency)) self.list.append(getConfigListEntry(_("Inversion"), self.scan_cab.inversion)) - self.list.append(getConfigListEntry(_("Symbol Rate"), self.scan_cab.symbolrate)) + self.list.append(getConfigListEntry(_("Symbol rate"), self.scan_cab.symbolrate)) self.list.append(getConfigListEntry(_("Modulation"), self.scan_cab.modulation)) self.list.append(getConfigListEntry(_("FEC"), self.scan_cab.fec)) - self.list.append(getConfigListEntry(_("Network scan"), self.scan_networkScan)) - elif self.scan_typecable.value == "complete": - self.list.append(getConfigListEntry(_("Clear before scan"), self.scan_clearallservices)) elif nim.isCompatible("DVB-T"): if self.scan_typeterrestrial.value == "single_transponder": - self.list.append(getConfigListEntry(_("Frequency"), self.scan_ter.frequency)) - self.list.append(getConfigListEntry(_("Inversion"), self.scan_ter.inversion)) - self.list.append(getConfigListEntry(_("Bandwidth"), self.scan_ter.bandwidth)) - self.list.append(getConfigListEntry(_("Code rate high"), self.scan_ter.fechigh)) - self.list.append(getConfigListEntry(_("Code rate low"), self.scan_ter.feclow)) - self.list.append(getConfigListEntry(_("Modulation"), self.scan_ter.modulation)) - self.list.append(getConfigListEntry(_("Transmission mode"), self.scan_ter.transmission)) - self.list.append(getConfigListEntry(_("Guard interval mode"), self.scan_ter.guard)) - self.list.append(getConfigListEntry(_("Hierarchy mode"), self.scan_ter.hierarchy)) - self.list.append(getConfigListEntry(_("Network scan"), self.scan_networkScan)) - elif self.scan_typeterrestrial.value == "complete": - self.list.append(getConfigListEntry(_("Clear before scan"), self.scan_clearallservices)) - -# if (nim.isCompatible("DVB-S") and self.scan_type.type == "single_transponder") or \ -# (nim.isCompatbile("DVB-C") and self.scan_typecable.type == "single_transponder") or \ -# (nim.isCompatible("DVB-T") and self.scan_typeterrestrial.type == "single_transponder"): -# self.configElementSNR = getConfigListEntry(_("SNR"), self.scan_snr) -# self.list.append(self.configElementSNR) -# self.configElementACG = getConfigListEntry(_("AGC"), self.scan_agc) -# self.list.append(self.configElementACG) -# self.configElementBER = getConfigListEntry(_("BER"), self.scan_ber) -# self.list.append(self.configElementBER) -# self.statusTimer.start(500, False) -# else: -# self.statusTimer.stop() - + if nim.isCompatible("DVB-T2"): + self.systemEntry = getConfigListEntry(_('System'), self.scan_ter.system) + self.list.append(self.systemEntry) + else: + self.scan_ter.system.value = eDVBFrontendParametersTerrestrial.System_DVB_T + if self.scan_ter.system.value == eDVBFrontendParametersTerrestrial.System_DVB_T: + self.list.append(getConfigListEntry(_("Frequency"), self.scan_ter.frequency)) + self.list.append(getConfigListEntry(_("Inversion"), self.scan_ter.inversion)) + self.list.append(getConfigListEntry(_("Bandwidth"), self.scan_ter.bandwidth)) + self.list.append(getConfigListEntry(_("Code rate HP"), self.scan_ter.fechigh)) + self.list.append(getConfigListEntry(_("Code rate LP"), self.scan_ter.feclow)) + self.list.append(getConfigListEntry(_("Modulation"), self.scan_ter.modulation)) + self.list.append(getConfigListEntry(_("Transmission mode"), self.scan_ter.transmission)) + self.list.append(getConfigListEntry(_("Guard interval"), self.scan_ter.guard)) + self.list.append(getConfigListEntry(_("Hierarchy info"), self.scan_ter.hierarchy)) + else: # DVB-T2 + self.list.append(getConfigListEntry(_("Frequency"), self.scan_ter.frequency)) + self.list.append(getConfigListEntry(_("Inversion"), self.scan_ter.inversion)) + self.list.append(getConfigListEntry(_("Bandwidth"), self.scan_ter.bandwidth_t2)) + self.list.append(getConfigListEntry(_("Code rate HP"), self.scan_ter.fechigh_t2)) + self.list.append(getConfigListEntry(_("Code rate LP"), self.scan_ter.feclow_t2)) + self.list.append(getConfigListEntry(_("Modulation"), self.scan_ter.modulation_t2)) + self.list.append(getConfigListEntry(_("Transmission mode"), self.scan_ter.transmission_t2)) + self.list.append(getConfigListEntry(_("Guard interval"), self.scan_ter.guard_t2)) + self.list.append(getConfigListEntry(_("Hierarchy info"), self.scan_ter.hierarchy)) + self.list.append(getConfigListEntry(_('PLP ID'), self.scan_ter.plp_id)) + self.list.append(getConfigListEntry(_("Network scan"), self.scan_networkScan)) + self.list.append(getConfigListEntry(_("Clear before scan"), self.scan_clearallservices)) + self.list.append(getConfigListEntry(_("Only Free scan"), self.scan_onlyfree)) self["config"].list = self.list self["config"].l.setList(self.list) @@ -469,7 +677,7 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport): if cur == self.typeOfScanEntry or \ cur == self.tunerEntry or \ cur == self.systemEntry or \ - (self.modulationEntry and self.systemEntry[1].value == "dvb-s2" and cur == self.modulationEntry): + (self.modulationEntry and self.systemEntry[1].value == eDVBFrontendParametersSatellite.System_DVB_S2 and cur == self.modulationEntry): self.createSetup() def createConfig(self, frontendData): @@ -503,50 +711,93 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport): #("Transmission Mode", frontendData["transmission_mode"], TYPE_TEXT), #("Guard Interval", frontendData["guard_interval"], TYPE_TEXT), #("Hierarchy Inform.", frontendData["hierarchy_information"], TYPE_TEXT), - defaultSat = { "orbpos": 192, "system": "dvb-s", "frequency": 11836, "inversion": "auto", "symbolrate": 27500, "polarization": "horizontal", "fec": "auto", "fec_s2": "9_10", "modulation": "qpsk" } - defaultCab = {"frequency": 466, "inversion": "auto", "modulation": "64qam", "fec": "auto", "symbolrate": 6900} + defaultSat = { + "orbpos": 192, + "system": eDVBFrontendParametersSatellite.System_DVB_S, + "frequency": 11836, + "inversion": eDVBFrontendParametersSatellite.Inversion_Unknown, + "symbolrate": 27500, + "polarization": eDVBFrontendParametersSatellite.Polarisation_Horizontal, + "fec": eDVBFrontendParametersSatellite.FEC_Auto, + "fec_s2": eDVBFrontendParametersSatellite.FEC_9_10, + "modulation": eDVBFrontendParametersSatellite.Modulation_QPSK } + defaultCab = { + "frequency": 466, + "inversion": eDVBFrontendParametersCable.Inversion_Unknown, + "modulation": eDVBFrontendParametersCable.Modulation_QAM64, + "fec": eDVBFrontendParametersCable.FEC_Auto, + "symbolrate": 6900 } + defaultTer = { + "frequency" : 466000, + "inversion" : eDVBFrontendParametersTerrestrial.Inversion_Unknown, + "bandwidth" : eDVBFrontendParametersTerrestrial.Bandwidth_7MHz, + "fechigh" : eDVBFrontendParametersTerrestrial.FEC_Auto, + "feclow" : eDVBFrontendParametersTerrestrial.FEC_Auto, + "modulation" : eDVBFrontendParametersTerrestrial.Modulation_Auto, + "transmission_mode" : eDVBFrontendParametersTerrestrial.TransmissionMode_Auto, + "guard_interval" : eDVBFrontendParametersTerrestrial.GuardInterval_Auto, + "hierarchy": eDVBFrontendParametersTerrestrial.Hierarchy_Auto, + "system": eDVBFrontendParametersTerrestrial.System_DVB_T, + "plp_id": 0 } + if frontendData is not None: ttype = frontendData.get("tuner_type", "UNKNOWN") if ttype == "DVB-S": - defaultSat["system"] = {"DVB-S": "dvb-s", "DVB-S2": "dvb-s2"}[frontendData.get("system", "DVB-S")] - defaultSat["frequency"] = int(frontendData.get("frequency", 0) / 1000) - defaultSat["inversion"] = {"INVERSION_OFF": "off", "INVERSION_ON": "on", "INVERSION_AUTO": "auto"}[frontendData.get("inversion", "INVERSION_AUTO")] - defaultSat["symbolrate"] = int(frontendData.get("symbol_rate", 0) / 1000) - defaultSat["polarization"] = {"HORIZONTAL": "horizontal", "VERTICAL": "vertical", "CIRCULAR_LEFT": "circular_left", "CIRCULAR_RIGHT": "circular_right", "UNKNOWN": None}[frontendData.get("polarization", "HORIZONTAL")] - - if frontendData.get("system", "DVB-S") == "DVB-S2": - defaultSat["fec_s2"] = {"FEC_1_2": "1_2", "FEC_2_3": "2_3", "FEC_3_4": "3_4", "FEC_4_5": "4_5", "FEC_5_6": "5_6", "FEC_7_8": "7_8", "FEC_8_9": "8_9", "FEC_9_10": "9_10"} \ - [frontendData.get("fec_inner", "FEC_AUTO")] - defaultSat["rolloff"] = {"ROLLOFF_0_35" : "0_35", "ROLLOFF_0_25" : "0_25", "ROLLOFF_0_20" : "0_20"}[frontendData.get("rolloff", "ROLLOFF_0_35")] - defaultSat["pilot"] = {"PILOT_ON" : "on", "PILOT_OFF" : "off", "PILOT_AUTO" : "auto"}[frontendData.get("pilot", "PILOT_AUTO")] + defaultSat["system"] = frontendData.get("system", eDVBFrontendParametersSatellite.System_DVB_S) + defaultSat["frequency"] = frontendData.get("frequency", 0) / 1000 + defaultSat["inversion"] = frontendData.get("inversion", eDVBFrontendParametersSatellite.Inversion_Unknown) + defaultSat["symbolrate"] = frontendData.get("symbol_rate", 0) / 1000 + defaultSat["polarization"] = frontendData.get("polarization", eDVBFrontendParametersSatellite.Polarisation_Horizontal) + if defaultSat["system"] == eDVBFrontendParametersSatellite.System_DVB_S2: + defaultSat["fec_s2"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto) + defaultSat["rolloff"] = frontendData.get("rolloff", eDVBFrontendParametersSatellite.RollOff_alpha_0_35) + defaultSat["pilot"] = frontendData.get("pilot", eDVBFrontendParametersSatellite.Pilot_Unknown) else: - defaultSat["fec"] = {"FEC_AUTO": "auto", "FEC_1_2": "1_2", "FEC_2_3": "2_3", "FEC_3_4": "3_4", "FEC_5_6": "5_6", "FEC_7_8": "7_8", "FEC_NONE": "none"} \ - [frontendData.get("fec_inner", "FEC_AUTO")] - - defaultSat["modulation"] = {"QPSK": "qpsk", "8PSK": "8psk"}[frontendData.get("modulation", "QPSK")] + defaultSat["fec"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto) + defaultSat["modulation"] = frontendData.get("modulation", eDVBFrontendParametersSatellite.Modulation_QPSK) defaultSat["orbpos"] = frontendData.get("orbital_position", 0) elif ttype == "DVB-C": - defaultCab["frequency"] = int(frontendData.get("frequency", 0) / 1000) - defaultCab["symbolrate"] = int(frontendData.get("symbol_rate", 0) / 1000) - defaultCab["inversion"] = {"INVERSION_OFF": "off", "INVERSION_ON": "on", "INVERSION_AUTO": "auto"}[frontendData.get("inversion", "INVERSION_AUTO")] - defaultCab["fec"] = {"FEC_AUTO": "auto", "FEC_1_2": "1_2", "FEC_2_3": "2_3", "FEC_3_4": "3_4", "FEC_5_6": "5_6", "FEC_7_8": "7_8", "FEC_8_9": "8_9", "FEC_NONE": "none"}[frontendData.get("fec_inner", "FEC_AUTO")] - defaultCab["modulation"] = {"QAM_AUTO": "auto", "QAM_16": "16qam", "QAM_32": "32qam", "QAM_64": "64qam", "QAM_128": "128qam", "QAM_256": "256qam"}[frontendData.get("modulation", "QAM_16")] + defaultCab["frequency"] = frontendData.get("frequency", 0) / 1000 + defaultCab["symbolrate"] = frontendData.get("symbol_rate", 0) / 1000 + defaultCab["inversion"] = frontendData.get("inversion", eDVBFrontendParametersCable.Inversion_Unknown) + defaultCab["fec"] = frontendData.get("fec_inner", eDVBFrontendParametersCable.FEC_Auto) + defaultCab["modulation"] = frontendData.get("modulation", eDVBFrontendParametersCable.Modulation_QAM16) + elif ttype == "DVB-T": + defaultTer["frequency"] = frontendData.get("frequency", 0) / 1000 + defaultTer["inversion"] = frontendData.get("inversion", eDVBFrontendParametersTerrestrial.Inversion_Unknown) + defaultTer["bandwidth"] = frontendData.get("bandwidth", eDVBFrontendParametersTerrestrial.Bandwidth_7MHz) + defaultTer["fechigh"] = frontendData.get("code_rate_hp", eDVBFrontendParametersTerrestrial.FEC_Auto) + defaultTer["feclow"] = frontendData.get("code_rate_lp", eDVBFrontendParametersTerrestrial.FEC_Auto) + defaultTer["modulation"] = frontendData.get("constellation", eDVBFrontendParametersTerrestrial.Modulation_Auto) + defaultTer["transmission_mode"] = frontendData.get("transmission_mode", eDVBFrontendParametersTerrestrial.TransmissionMode_Auto) + defaultTer["guard_interval"] = frontendData.get("guard_interval", eDVBFrontendParametersTerrestrial.GuardInterval_Auto) + defaultTer["hierarchy"] = frontendData.get("hierarchy_information", eDVBFrontendParametersTerrestrial.Hierarchy_Auto) + defaultTer["system"] = frontendData.get("system", eDVBFrontendParametersTerrestrial.System_DVB_T) + defaultTer["plp_id"] = frontendData.get("plp_id", 0) self.scan_sat = ConfigSubsection() self.scan_cab = ConfigSubsection() self.scan_ter = ConfigSubsection() - self.scan_type = ConfigSelection(default = "single_transponder", choices = [("single_transponder", _("Single transponder")), ("single_satellite", _("Single satellite")), ("multisat", _("Multisat"))]) + self.scan_type = ConfigSelection(default = "single_transponder", choices = [("single_transponder", _("Single transponder")), ("single_satellite", _("Single satellite")), ("multisat", _("Multisat")), ("multisat_yes", _("Multisat"))]) self.scan_typecable = ConfigSelection(default = "single_transponder", choices = [("single_transponder", _("Single transponder")), ("complete", _("Complete"))]) self.scan_typeterrestrial = ConfigSelection(default = "single_transponder", choices = [("single_transponder", _("Single transponder")), ("complete", _("Complete"))]) self.scan_clearallservices = ConfigSelection(default = "no", choices = [("no", _("no")), ("yes", _("yes")), ("yes_hold_feeds", _("yes (keep feeds)"))]) + self.scan_onlyfree = ConfigYesNo(default = False) self.scan_networkScan = ConfigYesNo(default = False) nim_list = [] # collect all nims which are *not* set to "nothing" for n in nimmanager.nim_slots: - if n.config_mode != "nothing": - nim_list.append((str(n.slot), n.friendly_full_description)) + if n.config_mode == "nothing": + continue + if n.config_mode == "advanced" and len(nimmanager.getSatListForNim(n.slot)) < 1: + continue + if n.config_mode in ("loopthrough", "satposdepends"): + root_id = nimmanager.sec.getRoot(n.slot_id, int(n.config.connectedTo.value)) + if n.type == nimmanager.nim_slots[root_id].type: # check if connected from a DVB-S to DVB-S2 Nim or vice versa + continue + nim_list.append((str(n.slot), n.friendly_full_description)) self.scan_nims = ConfigSelection(choices = nim_list) @@ -559,36 +810,172 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport): self.scan_ber.enabled = False # sat - self.scan_sat.system = ConfigSelection(default = defaultSat["system"], choices = [("dvb-s", _("DVB-S")), ("dvb-s2", _("DVB-S2"))]) + self.scan_sat.system = ConfigSelection(default = defaultSat["system"], choices = [ + (eDVBFrontendParametersSatellite.System_DVB_S, _("DVB-S")), + (eDVBFrontendParametersSatellite.System_DVB_S2, _("DVB-S2"))]) self.scan_sat.frequency = ConfigInteger(default = defaultSat["frequency"], limits = (1, 99999)) - self.scan_sat.inversion = ConfigSelection(default = defaultSat["inversion"], choices = [("off", _("off")), ("on", _("on")), ("auto", _("Auto"))]) + self.scan_sat.inversion = ConfigSelection(default = defaultSat["inversion"], choices = [ + (eDVBFrontendParametersSatellite.Inversion_Off, _("Off")), + (eDVBFrontendParametersSatellite.Inversion_On, _("On")), + (eDVBFrontendParametersSatellite.Inversion_Unknown, _("Auto"))]) self.scan_sat.symbolrate = ConfigInteger(default = defaultSat["symbolrate"], limits = (1, 99999)) - self.scan_sat.polarization = ConfigSelection(default = defaultSat["polarization"], choices = [("horizontal", _("horizontal")), ("vertical", _("vertical")), ("circular_left", _("circular left")), ("circular_right", _("circular right"))]) - self.scan_sat.fec = ConfigSelection(default = defaultSat["fec"], choices = [("auto", _("Auto")), ("1_2", "1/2"), ("2_3", "2/3"), ("3_4", "3/4"), ("5_6", "5/6"), ("7_8", "7/8"), ("none", _("None"))]) - self.scan_sat.fec_s2 = ConfigSelection(default = defaultSat["fec_s2"], choices = [("1_2", "1/2"), ("2_3", "2/3"), ("3_4", "3/4"), ("3_5", "3/5"), ("4_5", "4/5"), ("5_6", "5/6"), ("7_8", "7/8"), ("8_9", "8/9"), ("9_10", "9/10")]) - self.scan_sat.modulation = ConfigSelection(default = defaultSat["modulation"], choices = [("qpsk", "QPSK"), ("8psk", "8PSK")]) - self.scan_sat.rolloff = ConfigSelection(default = defaultSat.get("rolloff", "0_35"), choices = [("0_35", "0.35"), ("0_25", "0.25"), ("0_20", "0.20")]) - self.scan_sat.pilot = ConfigSelection(default = defaultSat.get("pilot", "auto"), choices = [("off", _("off")), ("on", _("on")), ("auto", _("Auto"))]) + self.scan_sat.polarization = ConfigSelection(default = defaultSat["polarization"], choices = [ + (eDVBFrontendParametersSatellite.Polarisation_Horizontal, _("horizontal")), + (eDVBFrontendParametersSatellite.Polarisation_Vertical, _("vertical")), + (eDVBFrontendParametersSatellite.Polarisation_CircularLeft, _("circular left")), + (eDVBFrontendParametersSatellite.Polarisation_CircularRight, _("circular right"))]) + self.scan_sat.fec = ConfigSelection(default = defaultSat["fec"], choices = [ + (eDVBFrontendParametersSatellite.FEC_Auto, _("Auto")), + (eDVBFrontendParametersSatellite.FEC_1_2, "1/2"), + (eDVBFrontendParametersSatellite.FEC_2_3, "2/3"), + (eDVBFrontendParametersSatellite.FEC_3_4, "3/4"), + (eDVBFrontendParametersSatellite.FEC_5_6, "5/6"), + (eDVBFrontendParametersSatellite.FEC_7_8, "7/8"), + (eDVBFrontendParametersSatellite.FEC_None, _("None"))]) + self.scan_sat.fec_s2 = ConfigSelection(default = defaultSat["fec_s2"], choices = [ + (eDVBFrontendParametersSatellite.FEC_1_2, "1/2"), + (eDVBFrontendParametersSatellite.FEC_2_3, "2/3"), + (eDVBFrontendParametersSatellite.FEC_3_4, "3/4"), + (eDVBFrontendParametersSatellite.FEC_3_5, "3/5"), + (eDVBFrontendParametersSatellite.FEC_4_5, "4/5"), + (eDVBFrontendParametersSatellite.FEC_5_6, "5/6"), + (eDVBFrontendParametersSatellite.FEC_7_8, "7/8"), + (eDVBFrontendParametersSatellite.FEC_8_9, "8/9"), + (eDVBFrontendParametersSatellite.FEC_9_10, "9/10")]) + self.scan_sat.modulation = ConfigSelection(default = defaultSat["modulation"], choices = [ + (eDVBFrontendParametersSatellite.Modulation_QPSK, "QPSK"), + (eDVBFrontendParametersSatellite.Modulation_8PSK, "8PSK")]) + self.scan_sat.rolloff = ConfigSelection(default = defaultSat.get("rolloff", eDVBFrontendParametersSatellite.RollOff_alpha_0_35), choices = [ + (eDVBFrontendParametersSatellite.RollOff_alpha_0_35, "0.35"), + (eDVBFrontendParametersSatellite.RollOff_alpha_0_25, "0.25"), + (eDVBFrontendParametersSatellite.RollOff_alpha_0_20, "0.20")]) + self.scan_sat.pilot = ConfigSelection(default = defaultSat.get("pilot", eDVBFrontendParametersSatellite.Pilot_Unknown), choices = [ + (eDVBFrontendParametersSatellite.Pilot_Off, _("Off")), + (eDVBFrontendParametersSatellite.Pilot_On, _("On")), + (eDVBFrontendParametersSatellite.Pilot_Unknown, _("Auto"))]) # cable self.scan_cab.frequency = ConfigInteger(default = defaultCab["frequency"], limits = (50, 999)) - self.scan_cab.inversion = ConfigSelection(default = defaultCab["inversion"], choices = [("off", _("off")), ("on", _("on")), ("auto", _("Auto"))]) - self.scan_cab.modulation = ConfigSelection(default = defaultCab["modulation"], choices = [("16qam", "16-QAM"), ("32qam", "32-QAM"), ("64qam", "64-QAM"), ("128qam", "128-QAM"), ("256qam", "256-QAM")]) - self.scan_cab.fec = ConfigSelection(default = defaultCab["fec"], choices = [("auto", _("Auto")), ("1_2", "1/2"), ("2_3", "2/3"), ("3_4", "3/4"), ("5_6", "5/6"), ("7_8", "7/8"), ("8_9", "8/9"), ("none", _("None"))]) + self.scan_cab.inversion = ConfigSelection(default = defaultCab["inversion"], choices = [ + (eDVBFrontendParametersCable.Inversion_Off, _("Off")), + (eDVBFrontendParametersCable.Inversion_On, _("On")), + (eDVBFrontendParametersCable.Inversion_Unknown, _("Auto"))]) + self.scan_cab.modulation = ConfigSelection(default = defaultCab["modulation"], choices = [ + (eDVBFrontendParametersCable.Modulation_QAM16, "16-QAM"), + (eDVBFrontendParametersCable.Modulation_QAM32, "32-QAM"), + (eDVBFrontendParametersCable.Modulation_QAM64, "64-QAM"), + (eDVBFrontendParametersCable.Modulation_QAM128, "128-QAM"), + (eDVBFrontendParametersCable.Modulation_QAM256, "256-QAM")]) + self.scan_cab.fec = ConfigSelection(default = defaultCab["fec"], choices = [ + (eDVBFrontendParametersCable.FEC_Auto, _("Auto")), + (eDVBFrontendParametersCable.FEC_1_2, "1/2"), + (eDVBFrontendParametersCable.FEC_2_3, "2/3"), + (eDVBFrontendParametersCable.FEC_3_4, "3/4"), + (eDVBFrontendParametersCable.FEC_5_6, "5/6"), + (eDVBFrontendParametersCable.FEC_7_8, "7/8"), + (eDVBFrontendParametersCable.FEC_8_9, "8/9"), + (eDVBFrontendParametersCable.FEC_None, _("None"))]) self.scan_cab.symbolrate = ConfigInteger(default = defaultCab["symbolrate"], limits = (1, 99999)) # terrestial - self.scan_ter.frequency = ConfigInteger(default = 466000, limits = (50000, 999000)) - self.scan_ter.inversion = ConfigSelection(default = "auto", choices = [("off", _("off")), ("on", _("on")), ("auto", _("Auto"))]) + self.scan_ter.frequency = ConfigInteger(default = defaultTer["frequency"], limits = (50000, 999000)) + self.scan_ter.inversion = ConfigSelection(default = defaultTer["inversion"], choices = [ + (eDVBFrontendParametersTerrestrial.Inversion_Off, _("Off")), + (eDVBFrontendParametersTerrestrial.Inversion_On, _("On")), + (eDVBFrontendParametersTerrestrial.Inversion_Unknown, _("Auto"))]) # WORKAROUND: we can't use BW-auto - self.scan_ter.bandwidth = ConfigSelection(default = "8MHz", choices = [("8MHz", "8MHz"), ("7MHz", "7MHz"), ("6MHz", "6MHz")]) - #, ("auto", _("Auto")))) - self.scan_ter.fechigh = ConfigSelection(default = "auto", choices = [("1_2", "1/2"), ("2_3", "2/3"), ("3_4", "3/4"), ("5_6", "5/6"), ("7_8", "7/8"), ("auto", _("Auto"))]) - self.scan_ter.feclow = ConfigSelection(default = "auto", choices = [("1_2", "1/2"), ("2_3", "2/3"), ("3_4", "3/4"), ("5_6", "5/6"), ("7_8", "7/8"), ("auto", _("Auto"))]) - self.scan_ter.modulation = ConfigSelection(default = "auto", choices = [("qpsk", "QPSK"), ("qam16", "QAM16"), ("qam64", "QAM64"), ("auto", _("Auto"))]) - self.scan_ter.transmission = ConfigSelection(default = "auto", choices = [("2k", "2K"), ("8k", "8K"), ("auto", _("Auto"))]) - self.scan_ter.guard = ConfigSelection(default = "auto", choices = [("1_32", "1/32"), ("1_16", "1/16"), ("1_8", "1/8"), ("1_4", "1/4"), ("auto", _("Auto"))]) - self.scan_ter.hierarchy = ConfigSelection(default = "auto", choices = [("none", _("None")), ("1", "1"), ("2", "2"), ("4", "4"), ("auto", _("Auto"))]) + self.scan_ter.bandwidth = ConfigSelection(default = defaultTer["bandwidth"], choices = [ + (eDVBFrontendParametersTerrestrial.Bandwidth_8MHz, "8MHz"), + (eDVBFrontendParametersTerrestrial.Bandwidth_7MHz, "7MHz"), + (eDVBFrontendParametersTerrestrial.Bandwidth_6MHz, "6MHz")]) + self.scan_ter.bandwidth_t2 = ConfigSelection(default = defaultTer["bandwidth"], choices = [ + (eDVBFrontendParametersTerrestrial.Bandwidth_10MHz, "10MHz"), + (eDVBFrontendParametersTerrestrial.Bandwidth_8MHz, "8MHz"), + (eDVBFrontendParametersTerrestrial.Bandwidth_7MHz, "7MHz"), + (eDVBFrontendParametersTerrestrial.Bandwidth_6MHz, "6MHz"), + (eDVBFrontendParametersTerrestrial.Bandwidth_5MHz, "5MHz"), + (eDVBFrontendParametersTerrestrial.Bandwidth_1_712MHz, "1.712MHz")]) + #, (eDVBFrontendParametersTerrestrial.Bandwidth_Auto, _("Auto")))) + self.scan_ter.fechigh = ConfigSelection(default = defaultTer["fechigh"], choices = [ + (eDVBFrontendParametersTerrestrial.FEC_1_2, "1/2"), + (eDVBFrontendParametersTerrestrial.FEC_2_3, "2/3"), + (eDVBFrontendParametersTerrestrial.FEC_3_4, "3/4"), + (eDVBFrontendParametersTerrestrial.FEC_5_6, "5/6"), + (eDVBFrontendParametersTerrestrial.FEC_7_8, "7/8"), + (eDVBFrontendParametersTerrestrial.FEC_Auto, _("Auto"))]) + self.scan_ter.fechigh_t2 = ConfigSelection(default = defaultTer["fechigh"], choices = [ + (eDVBFrontendParametersTerrestrial.FEC_1_2, "1/2"), + (eDVBFrontendParametersTerrestrial.FEC_2_3, "2/3"), + (eDVBFrontendParametersTerrestrial.FEC_3_4, "3/4"), + (eDVBFrontendParametersTerrestrial.FEC_5_6, "5/6"), + (eDVBFrontendParametersTerrestrial.FEC_6_7, "6/7"), + (eDVBFrontendParametersTerrestrial.FEC_7_8, "7/8"), + (eDVBFrontendParametersTerrestrial.FEC_8_9, "8/9"), + (eDVBFrontendParametersTerrestrial.FEC_Auto, _("Auto"))]) + self.scan_ter.feclow = ConfigSelection(default = defaultTer["feclow"], choices = [ + (eDVBFrontendParametersTerrestrial.FEC_1_2, "1/2"), + (eDVBFrontendParametersTerrestrial.FEC_2_3, "2/3"), + (eDVBFrontendParametersTerrestrial.FEC_3_4, "3/4"), + (eDVBFrontendParametersTerrestrial.FEC_5_6, "5/6"), + (eDVBFrontendParametersTerrestrial.FEC_7_8, "7/8"), + (eDVBFrontendParametersTerrestrial.FEC_Auto, _("Auto"))]) + self.scan_ter.feclow_t2 = ConfigSelection(default = defaultTer["feclow"], choices = [ + (eDVBFrontendParametersTerrestrial.FEC_1_2, "1/2"), + (eDVBFrontendParametersTerrestrial.FEC_2_3, "2/3"), + (eDVBFrontendParametersTerrestrial.FEC_3_4, "3/4"), + (eDVBFrontendParametersTerrestrial.FEC_5_6, "5/6"), + (eDVBFrontendParametersTerrestrial.FEC_6_7, "6/7"), + (eDVBFrontendParametersTerrestrial.FEC_7_8, "7/8"), + (eDVBFrontendParametersTerrestrial.FEC_8_9, "8/9"), + (eDVBFrontendParametersTerrestrial.FEC_Auto, _("Auto"))]) + self.scan_ter.modulation = ConfigSelection(default = defaultTer["modulation"], choices = [ + (eDVBFrontendParametersTerrestrial.Modulation_QPSK, "QPSK"), + (eDVBFrontendParametersTerrestrial.Modulation_QAM16, "QAM16"), + (eDVBFrontendParametersTerrestrial.Modulation_QAM64, "QAM64"), + (eDVBFrontendParametersTerrestrial.Modulation_Auto, _("Auto"))]) + self.scan_ter.modulation_t2 = ConfigSelection(default = defaultTer["modulation"], choices = [ + (eDVBFrontendParametersTerrestrial.Modulation_QPSK, "QPSK"), + (eDVBFrontendParametersTerrestrial.Modulation_QAM16, "QAM16"), + (eDVBFrontendParametersTerrestrial.Modulation_QAM64, "QAM64"), + (eDVBFrontendParametersTerrestrial.Modulation_QAM256, "QAM256"), + (eDVBFrontendParametersTerrestrial.Modulation_Auto, _("Auto"))]) + self.scan_ter.transmission = ConfigSelection(default = defaultTer["transmission_mode"], choices = [ + (eDVBFrontendParametersTerrestrial.TransmissionMode_2k, "2K"), + (eDVBFrontendParametersTerrestrial.TransmissionMode_8k, "8K"), + (eDVBFrontendParametersTerrestrial.TransmissionMode_Auto, _("Auto"))]) + self.scan_ter.transmission_t2 = ConfigSelection(default = defaultTer["transmission_mode"], choices = [ + (eDVBFrontendParametersTerrestrial.TransmissionMode_1k, "1K"), + (eDVBFrontendParametersTerrestrial.TransmissionMode_2k, "2K"), + (eDVBFrontendParametersTerrestrial.TransmissionMode_4k, "4K"), + (eDVBFrontendParametersTerrestrial.TransmissionMode_8k, "8K"), + (eDVBFrontendParametersTerrestrial.TransmissionMode_16k, "16K"), + (eDVBFrontendParametersTerrestrial.TransmissionMode_32k, "32K"), + (eDVBFrontendParametersTerrestrial.TransmissionMode_Auto, _("Auto"))]) + self.scan_ter.guard = ConfigSelection(default = defaultTer["guard_interval"], choices = [ + (eDVBFrontendParametersTerrestrial.GuardInterval_1_32, "1/32"), + (eDVBFrontendParametersTerrestrial.GuardInterval_1_16, "1/16"), + (eDVBFrontendParametersTerrestrial.GuardInterval_1_8, "1/8"), + (eDVBFrontendParametersTerrestrial.GuardInterval_1_4, "1/4"), + (eDVBFrontendParametersTerrestrial.GuardInterval_Auto, _("Auto"))]) + self.scan_ter.guard_t2 = ConfigSelection(default = defaultTer["guard_interval"], choices = [ + (eDVBFrontendParametersTerrestrial.GuardInterval_19_256, "19/256"), + (eDVBFrontendParametersTerrestrial.GuardInterval_19_128, "19/128"), + (eDVBFrontendParametersTerrestrial.GuardInterval_1_128, "1/128"), + (eDVBFrontendParametersTerrestrial.GuardInterval_1_32, "1/32"), + (eDVBFrontendParametersTerrestrial.GuardInterval_1_16, "1/16"), + (eDVBFrontendParametersTerrestrial.GuardInterval_1_8, "1/8"), + (eDVBFrontendParametersTerrestrial.GuardInterval_1_4, "1/4"), + (eDVBFrontendParametersTerrestrial.GuardInterval_Auto, _("Auto"))]) + self.scan_ter.hierarchy = ConfigSelection(default = defaultTer["hierarchy"], choices = [ + (eDVBFrontendParametersTerrestrial.Hierarchy_None, _("None")), + (eDVBFrontendParametersTerrestrial.Hierarchy_1, "1"), + (eDVBFrontendParametersTerrestrial.Hierarchy_2, "2"), + (eDVBFrontendParametersTerrestrial.Hierarchy_4, "4"), + (eDVBFrontendParametersTerrestrial.Hierarchy_Auto, _("Auto"))]) + self.scan_ter.system = ConfigSelection(default = defaultTer["system"], choices = [ + (eDVBFrontendParametersTerrestrial.System_DVB_T, _("DVB-T")), + (eDVBFrontendParametersTerrestrial.System_DVB_T2, _("DVB-T2"))]) + self.scan_ter.plp_id = ConfigInteger(default = defaultTer["plp_id"], limits = (0, 255)) self.scan_scansat = {} for sat in nimmanager.satList: @@ -598,7 +985,7 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport): self.scan_satselection = [] for slot in nimmanager.nim_slots: if slot.isCompatible("DVB-S"): - self.scan_satselection.append(getConfigSatlist(int(defaultSat["orbpos"]), self.satList[slot.slot])) + self.scan_satselection.append(getConfigSatlist(defaultSat["orbpos"], self.satList[slot.slot])) else: self.scan_satselection.append(None) @@ -615,36 +1002,20 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport): def updateStatus(self): print "updatestatus" - fecmap = { "auto": 0, - "1_2": 1, - "2_3": 2, - "3_4": 3, - "5_6": 4, - "7_8": 5, - "8_9": 6, - "3_5": 7, - "4_5": 8, - "9_10": 9, - "none": 15 - } - def addSatTransponder(self, tlist, frequency, symbol_rate, polarisation, fec, inversion, orbital_position, system, modulation, rolloff, pilot): - print "Add Sat: frequ: " + str(frequency) + " symbol: " + str(symbol_rate) + " pol: " + str(polarisation) + " fec: " + str(self.fecmap[fec]) + " inversion: " + str(inversion) + " modulation: " + str(modulation) + " system: " + str(system) + " rolloff" + str(rolloff) + " pilot" + str(pilot) + print "Add Sat: frequ: " + str(frequency) + " symbol: " + str(symbol_rate) + " pol: " + str(polarisation) + " fec: " + str(fec) + " inversion: " + str(inversion) + " modulation: " + str(modulation) + " system: " + str(system) + " rolloff" + str(rolloff) + " pilot" + str(pilot) print "orbpos: " + str(orbital_position) parm = eDVBFrontendParametersSatellite() - if modulation == 1: - parm.modulation = 2 # eDVBFrontendParametersSatellite.Modulation.8PSK - else: - parm.modulation = 1 # eDVBFrontendParametersSatellite.Modulation.QPSK + parm.modulation = modulation parm.system = system parm.frequency = frequency * 1000 parm.symbol_rate = symbol_rate * 1000 parm.polarisation = polarisation - parm.fec = self.fecmap[fec] + parm.fec = fec parm.inversion = inversion - parm.orbital_position = int(orbital_position) - parm.rolloff = int(rolloff) - parm.pilot = int(pilot) + parm.orbital_position = orbital_position + parm.rolloff = rolloff + parm.pilot = pilot tlist.append(parm) def addCabTransponder(self, tlist, frequency, symbol_rate, modulation, fec, inversion): @@ -653,7 +1024,7 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport): parm.frequency = frequency * 1000 parm.symbol_rate = symbol_rate * 1000 parm.modulation = modulation - parm.fec = self.fecmap[fec] + parm.fec = fec parm.inversion = inversion tlist.append(parm) @@ -661,11 +1032,16 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport): tlist.append(buildTerTransponder(*args, **kwargs)) def keyGo(self): + START_SCAN =0 + SEARCH_CABLE_TRANSPONDERS = 1 + SEARCH_TERRESTRIAL2_TRANSPONDERS = 2 + + if self.scan_nims.value == "": + return tlist = [] flags = None - extFlags = True - - startScan = True + action = START_SCAN + removeAll = True index_to_scan = int(self.scan_nims.value) if self.scan_nims == [ ]: @@ -687,27 +1063,26 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport): # however, the satList itself could be empty. in that case, "index" is 0 (for "None"). if len(nimsats): orbpos = nimsats[selsatidx][0] - if self.scan_sat.system.value == "dvb-s": + if self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S: fec = self.scan_sat.fec.value else: fec = self.scan_sat.fec_s2.value print "add sat transponder" self.addSatTransponder(tlist, self.scan_sat.frequency.value, self.scan_sat.symbolrate.value, - self.scan_sat.polarization.index, + self.scan_sat.polarization.value, fec, - self.scan_sat.inversion.index, + self.scan_sat.inversion.value, orbpos, - self.scan_sat.system.index, - self.scan_sat.modulation.index, - self.scan_sat.rolloff.index, - self.scan_sat.pilot.index) - flags = self.scan_networkScan.value and eComponentScan.scanNetworkSearch or 0 - extFlags = False + self.scan_sat.system.value, + self.scan_sat.modulation.value, + self.scan_sat.rolloff.value, + self.scan_sat.pilot.value) + removeAll = False elif self.scan_type.value == "single_satellite": sat = self.satList[index_to_scan][self.scan_satselection[index_to_scan].index] getInitialTransponderList(tlist, sat[0]) - elif self.scan_type.value == "multisat": + elif self.scan_type.value.find("multisat") != -1: SatList = nimmanager.getSatListForNim(index_to_scan) for x in self.multiscanlist: if x[1].value: @@ -716,64 +1091,107 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport): elif nim.isCompatible("DVB-C"): if self.scan_typecable.value == "single_transponder": - fec = self.scan_cab.fec.value self.addCabTransponder(tlist, self.scan_cab.frequency.value, self.scan_cab.symbolrate.value, - self.scan_cab.modulation.index + 1, - fec, - self.scan_cab.inversion.index) - flags = self.scan_networkScan.value and eComponentScan.scanNetworkSearch or 0 - extFlags = False + self.scan_cab.modulation.value, + self.scan_cab.fec.value, + self.scan_cab.inversion.value) + removeAll = False elif self.scan_typecable.value == "complete": if config.Nims[index_to_scan].cable.scan_type.value == "provider": getInitialCableTransponderList(tlist, index_to_scan) else: - startScan = False + action = SEARCH_CABLE_TRANSPONDERS elif nim.isCompatible("DVB-T"): if self.scan_typeterrestrial.value == "single_transponder": - self.addTerTransponder(tlist, - self.scan_ter.frequency.value * 1000, - inversion = self.scan_ter.inversion.index, - bandwidth = self.scan_ter.bandwidth.index, - fechigh = self.scan_ter.fechigh.index, - feclow = self.scan_ter.feclow.index, - modulation = self.scan_ter.modulation.index, - transmission = self.scan_ter.transmission.index, - guard = self.scan_ter.guard.index, - hierarchy = self.scan_ter.hierarchy.index) - flags = self.scan_networkScan.value and eComponentScan.scanNetworkSearch or 0 - extFlags = False + if self.scan_ter.system.value == eDVBFrontendParametersTerrestrial.System_DVB_T: + self.addTerTransponder(tlist, + self.scan_ter.frequency.value * 1000, + inversion = self.scan_ter.inversion.value, + bandwidth = self.scan_ter.bandwidth.value, + fechigh = self.scan_ter.fechigh.value, + feclow = self.scan_ter.feclow.value, + modulation = self.scan_ter.modulation.value, + transmission = self.scan_ter.transmission.value, + guard = self.scan_ter.guard.value, + hierarchy = self.scan_ter.hierarchy.value, + system = self.scan_ter.system.value, + plpid = self.scan_ter.plp_id.value) + else: + self.addTerTransponder(tlist, + self.scan_ter.frequency.value * 1000, + inversion = self.scan_ter.inversion.value, + bandwidth = self.scan_ter.bandwidth_t2.value, + fechigh = self.scan_ter.fechigh_t2.value, + feclow = self.scan_ter.feclow_t2.value, + modulation = self.scan_ter.modulation_t2.value, + transmission = self.scan_ter.transmission_t2.value, + guard = self.scan_ter.guard_t2.value, + hierarchy = self.scan_ter.hierarchy.value, + system = self.scan_ter.system.value, + plpid = self.scan_ter.plp_id.value) + removeAll = False elif self.scan_typeterrestrial.value == "complete": - getInitialTerrestrialTransponderList(tlist, nimmanager.getTerrestrialDescription(index_to_scan)) + skip_t2 = True + if nim.isCompatible("DVB-T2"): + scan_util = len(self.terrestrialTransponderGetCmd(nim.slot)) and True or False + if scan_util: + action = SEARCH_TERRESTRIAL2_TRANSPONDERS + else: + skip_t2 = False - if flags is None: - flags = eComponentScan.scanNetworkSearch + getInitialTerrestrialTransponderList(tlist, nimmanager.getTerrestrialDescription(index_to_scan), skip_t2) - if extFlags: - tmp = self.scan_clearallservices.value - if tmp == "yes": - flags |= eComponentScan.scanRemoveServices - elif tmp == "yes_hold_feeds": - flags |= eComponentScan.scanRemoveServices - flags |= eComponentScan.scanDontRemoveFeeds + flags = self.scan_networkScan.value and eComponentScan.scanNetworkSearch or 0 + + tmp = self.scan_clearallservices.value + if tmp == "yes": + flags |= eComponentScan.scanRemoveServices + elif tmp == "yes_hold_feeds": + flags |= eComponentScan.scanRemoveServices + flags |= eComponentScan.scanDontRemoveFeeds + + if tmp != "no" and not removeAll: + flags |= eComponentScan.scanDontRemoveUnscanned + + if self.scan_onlyfree.value: + flags |= eComponentScan.scanOnlyFree for x in self["config"].list: x[1].save() - if startScan: + if action == START_SCAN: self.startScan(tlist, flags, index_to_scan) - else: + elif action == SEARCH_CABLE_TRANSPONDERS: self.flags = flags self.feid = index_to_scan self.tlist = [] self.startCableTransponderSearch(self.feid) + elif action == SEARCH_TERRESTRIAL2_TRANSPONDERS: + self.flags = flags + self.feid = index_to_scan + self.tlist = tlist + self.startTerrestrialTransponderSearch(self.feid, nimmanager.getTerrestrialDescription(self.feid)) def setCableTransponderSearchResult(self, tlist): self.tlist = tlist def cableTransponderSearchFinished(self): - self.startScan(self.tlist, self.flags, self.feid) + if self.tlist is None: + self.tlist = [] + else: + self.startScan(self.tlist, self.flags, self.feid) + + def setTerrestrialTransponderSearchResult(self, tlist): + if tlist is not None: + self.tlist.extend(tlist) + + def terrestrialTransponderSearchFinished(self): + if self.tlist is None: + self.tlist = [] + else: + self.startScan(self.tlist, self.flags, self.feid) def startScan(self, tlist, flags, feid): if len(tlist): @@ -793,24 +1211,12 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport): x[1].cancel() self.close() -class ScanSimple(ConfigListScreen, Screen, CableTransponderSearchSupport): +class ScanSimple(ConfigListScreen, Screen, CableTransponderSearchSupport, TerrestrialTransponderSearchSupport): def getNetworksForNim(self, nim): if nim.isCompatible("DVB-S"): networks = nimmanager.getSatListForNim(nim.slot) -# the original code took "loopthrough" etc. into account. Do we need this? -# if nimmanager.getNimConfigMode(1) in ["loopthrough", "satposdepends", "equal", "nothing"]: -# return False -# sec = eDVBSatelliteEquipmentControl.getInstance() -# if sec is not None: -# exclusive_satellites = sec.get_exclusive_satellites(0,1) -# if len(exclusive_satellites) == 2: -# return False -# idx = exclusive_satellites[0]+1 -# exclusive_nim_sats = exclusive_satellites[idx+1:idx+1+exclusive_satellites[idx]] -# if len(exclusive_nim_sats): -# return True elif not nim.empty: - networks = [ nim.type ] # "DVB-C" or "DVB-T". TODO: seperate networks for different C/T tuners, if we want to support that. + networks = [ nim.getType() ] # "DVB-C" or "DVB-T". TODO: seperate networks for different C/T tuners, if we want to support that. else: # empty tuners provide no networks. networks = [ ] @@ -848,10 +1254,24 @@ class ScanSimple(ConfigListScreen, Screen, CableTransponderSearchSupport): need_scan = True print x, "not in ", known_networks known_networks.append(x) + + # don't offer to scan nims if nothing is connected + if not nimmanager.somethingConnected(nim.slot): + need_scan = False if need_scan: nims_to_scan.append(nim) + + if "DVB-T2" in known_networks: # we need to remove "DVB-T" when networks have "DVB-T2" + nims_dvb_t = [] + for nim in nims_to_scan: + if nim.getType() == "DVB-T": + nims_dvb_t.append(nim) + + for nim in nims_dvb_t: + nims_to_scan.remove(nim) + # we save the config elements to use them on keyGo self.nim_enable = [ ] @@ -882,6 +1302,7 @@ class ScanSimple(ConfigListScreen, Screen, CableTransponderSearchSupport): def buildTransponderList(self): # this method is called multiple times because of asynchronous stuff APPEND_NOW = 0 SEARCH_CABLE_TRANSPONDERS = 1 + SEARCH_TERRESTRIAL2_TRANSPONDERS = 2 action = APPEND_NOW n = self.nim_iter < len(self.nim_enable) and self.nim_enable[self.nim_iter] or None @@ -906,7 +1327,14 @@ class ScanSimple(ConfigListScreen, Screen, CableTransponderSearchSupport): else: action = SEARCH_CABLE_TRANSPONDERS elif nim.isCompatible("DVB-T"): - getInitialTerrestrialTransponderList(tlist, nimmanager.getTerrestrialDescription(nim.slot)) + skip_t2 = True + if nim.isCompatible("DVB-T2"): + scan_util = len(self.terrestrialTransponderGetCmd(nim.slot)) and True or False + if scan_util: + action = SEARCH_TERRESTRIAL2_TRANSPONDERS + else: + skip_t2 = False + getInitialTerrestrialTransponderList(tlist, nimmanager.getTerrestrialDescription(nim.slot), skip_t2) else: assert False @@ -925,6 +1353,12 @@ class ScanSimple(ConfigListScreen, Screen, CableTransponderSearchSupport): self.feid = nim.slot self.startCableTransponderSearch(nim.slot) return + elif action == SEARCH_TERRESTRIAL2_TRANSPONDERS: + self.tlist = tlist + self.flags = flags + self.feid = nim.slot + self.startTerrestrialTransponderSearch(nim.slot, nimmanager.getTerrestrialDescription(nim.slot)) + return else: assert False @@ -947,11 +1381,21 @@ class ScanSimple(ConfigListScreen, Screen, CableTransponderSearchSupport): self.session.open(MessageBox, _("Nothing to scan!\nPlease setup your tuner settings before you start a service scan."), MessageBox.TYPE_ERROR) def setCableTransponderSearchResult(self, tlist): - self.scanList.append({"transponders": tlist, "feid": self.feid, "flags": self.flags}) + if tlist is not None: + self.scanList.append({"transponders": tlist, "feid": self.feid, "flags": self.flags}) def cableTransponderSearchFinished(self): self.buildTransponderList() + def setTerrestrialTransponderSearchResult(self, tlist): + if tlist is not None: + self.tlist.extend(tlist) + if self.tlist is not None: + self.scanList.append({"transponders": self.tlist, "feid": self.feid, "flags": self.flags}) + + def terrestrialTransponderSearchFinished(self): + self.buildTransponderList() + def keyCancel(self): self.close()