def createConfig(self, foo): self.preDefTransponders = None self.tuning_type = ConfigSelection(choices = [("manual_transponder", _("User defined transponder")), ("predefined_transponder", _("Predefined transponder"))]) self.orbital_position = 192 if self.frontendData and self.frontendData.has_key('orbital_position'): self.orbital_position = self.frontendData['orbital_position'] ScanSetup.createConfig(self, self.frontendData) for x in (self.tuning_type, self.scan_sat.frequency, self.scan_sat.inversion, self.scan_sat.symbolrate, self.scan_sat.polarization, self.scan_sat.fec, self.scan_sat.pilot, self.scan_sat.fec_s2, self.scan_sat.fec, self.scan_sat.modulation, self.scan_sat.rolloff, self.scan_sat.system): x.addNotifier(self.retune, initial_call = False) satfinder_nim_list = [] for n in nimmanager.nim_slots: if not n.isCompatible("DVB-S"): continue if n.config_mode in ("loopthrough", "satposdepends", "nothing"): continue if n.config_mode == "advanced" and len(nimmanager.getSatListForNim(n.slot)) < 1: continue satfinder_nim_list.append((str(n.slot), n.friendly_full_description)) self.satfinder_scan_nims = ConfigSelection(choices = satfinder_nim_list) self.feid = int(self.satfinder_scan_nims.value) self.satList = [] self.scan_satselection = [] for slot in nimmanager.nim_slots: if slot.isCompatible("DVB-S"): self.satList.append(nimmanager.getSatListForNim(slot.slot)) self.scan_satselection.append(getConfigSatlist(self.orbital_position, self.satList[slot.slot])) else: self.satList.append(None)
def createConfig(self, foo): self.preDefTransponders = None self.tuning_type = ConfigSelection(choices = [("manual_transponder", _("User defined transponder")), ("predefined_transponder", _("Predefined transponder"))], default = "predefined_transponder") self.orbital_position = 192 if self.frontendData and self.frontendData.has_key('orbital_position'): self.orbital_position = self.frontendData['orbital_position'] ScanSetup.createConfig(self, self.frontendData) for x in (self.tuning_type, self.scan_sat.frequency, self.scan_sat.inversion, self.scan_sat.symbolrate, self.scan_sat.polarization, self.scan_sat.fec, self.scan_sat.pilot, self.scan_sat.fec_s2, self.scan_sat.fec, self.scan_sat.modulation, self.scan_sat.rolloff, self.scan_sat.system): x.addNotifier(self.retune, initial_call = False) satfinder_nim_list = [] for n in nimmanager.nim_slots: if not n.isCompatible("DVB-S"): continue if n.config_mode in ("loopthrough", "satposdepends", "nothing"): continue if n.config_mode == "advanced" and len(nimmanager.getSatListForNim(n.slot)) < 1: continue satfinder_nim_list.append((str(n.slot), n.friendly_full_description)) self.satfinder_scan_nims = ConfigSelection(choices = satfinder_nim_list) self.feid = int(self.satfinder_scan_nims.value) self.satList = [] self.scan_satselection = [] for slot in nimmanager.nim_slots: if slot.isCompatible("DVB-S"): self.satList.append(nimmanager.getSatListForNim(slot.slot)) self.scan_satselection.append(getConfigSatlist(self.orbital_position, self.satList[slot.slot])) else: self.satList.append(None)
def createConfig(self, foo): self.tuning_type = ConfigSelection(default = "predefined_transponder", choices = [("single_transponder", _("User defined transponder")), ("predefined_transponder", _("Predefined transponder"))]) self.orbital_position = 192 if self.frontendData and self.frontendData.has_key('orbital_position'): self.orbital_position = self.frontendData['orbital_position'] ScanSetup.createConfig(self, self.frontendData) for x in (self.scan_sat.frequency, self.scan_sat.inversion, self.scan_sat.symbolrate, self.scan_sat.polarization, self.scan_sat.fec, self.scan_sat.pilot, self.scan_sat.fec_s2, self.scan_sat.fec, self.scan_sat.modulation, self.scan_sat.rolloff, self.scan_sat.system, self.scan_ter.channel, self.scan_ter.frequency, self.scan_ter.inversion, self.scan_ter.bandwidth, self.scan_ter.fechigh, self.scan_ter.feclow, self.scan_ter.modulation, self.scan_ter.transmission, self.scan_ter.guard, self.scan_ter.hierarchy, self.scan_ter.plp_id, self.scan_cab.frequency, self.scan_cab.inversion, self.scan_cab.symbolrate, self.scan_cab.modulation, self.scan_cab.fec): x.addNotifier(self.retune, initial_call = False) satfinder_nim_list = [] for n in nimmanager.nim_slots: if not (n.isCompatible("DVB-S") or n.isCompatible("DVB-T") or n.isCompatible("DVB-C")): continue if n.config_mode in ("loopthrough", "satposdepends", "nothing"): continue if n.isCompatible("DVB-S") and len(nimmanager.getSatListForNim(n.slot)) < 1: continue if n.isCompatible("DVB-S") and n.isFBCTuner() and not n.isFBCRoot(): continue satfinder_nim_list.append((str(n.slot), n.friendly_full_description)) self.satfinder_scan_nims = ConfigSelection(choices = satfinder_nim_list) if self.frontendData is not None and len(satfinder_nim_list) > 0: # open the plugin with the currently active NIM as default active_nim = self.frontendData.get("tuner_number", int(satfinder_nim_list[0][0])) if not nimmanager.nim_slots[active_nim].isFBCLink(): self.satfinder_scan_nims.setValue(str(active_nim)) self.feid = int(self.satfinder_scan_nims.value) self.satList = [] self.scan_satselection = [] for slot in nimmanager.nim_slots: if slot.isCompatible("DVB-S"): self.satList.append(nimmanager.getSatListForNim(slot.slot)) self.scan_satselection.append(getConfigSatlist(self.orbital_position, self.satList[slot.slot])) else: self.satList.append(None) if self.frontendData: ttype = self.frontendData.get("tuner_type", "UNKNOWN") if ttype == "DVB-S" and self.predefinedTranspondersList(self.getSelectedSatIndex(self.feid)) is None and len(nimmanager.getTransponders(self.getSelectedSatIndex(self.feid))) > 0: self.tuning_type.value = "single_transponder" elif ttype == "DVB-T" and self.predefinedTerrTranspondersList() is None and len(nimmanager.getTranspondersTerrestrial(nimmanager.getTerrestrialDescription(self.feid))) > 0: self.tuning_type.value = "single_transponder" elif ttype == "DVB-C" and self.predefinedCabTranspondersList() is None and len(nimmanager.getTranspondersCable(self.feid)) > 0: self.tuning_type.value = "single_transponder"
def createConfig(self, foo): self.tuning_type = ConfigSelection(default = "predefined_transponder", choices = [("single_transponder", _("User defined transponder")), ("predefined_transponder", _("Predefined transponder"))]) self.orbital_position = 192 if self.frontendData and self.frontendData.has_key('orbital_position'): self.orbital_position = self.frontendData['orbital_position'] ScanSetup.createConfig(self, self.frontendData) for x in (self.scan_sat.frequency, self.scan_sat.inversion, self.scan_sat.symbolrate, self.scan_sat.polarization, self.scan_sat.fec, self.scan_sat.pilot, self.scan_sat.fec_s2, self.scan_sat.fec, self.scan_sat.modulation, self.scan_sat.rolloff, self.scan_sat.system, self.scan_sat.is_id, self.scan_sat.pls_mode, self.scan_sat.pls_code, self.scan_ter.channel, self.scan_ter.frequency, self.scan_ter.inversion, self.scan_ter.bandwidth, self.scan_ter.fechigh, self.scan_ter.feclow, self.scan_ter.modulation, self.scan_ter.transmission, self.scan_ter.guard, self.scan_ter.hierarchy, self.scan_ter.plp_id, self.scan_cab.frequency, self.scan_cab.inversion, self.scan_cab.symbolrate, self.scan_cab.modulation, self.scan_cab.fec): x.addNotifier(self.retune, initial_call = False) satfinder_nim_list = [] for n in nimmanager.nim_slots: if not (n.isCompatible("DVB-S") or n.isCompatible("DVB-T") or n.isCompatible("DVB-C")): continue if n.config_mode in ("loopthrough", "satposdepends", "nothing"): continue if n.isCompatible("DVB-S") and n.config_mode == "advanced" and len(nimmanager.getSatListForNim(n.slot)) < 1: continue satfinder_nim_list.append((str(n.slot), n.friendly_full_description)) self.satfinder_scan_nims = ConfigSelection(choices = satfinder_nim_list) if self.frontendData is not None and len(satfinder_nim_list) > 0: # open the plugin with the currently active NIM as default self.satfinder_scan_nims.setValue(str(self.frontendData.get("tuner_number", satfinder_nim_list[0][0]))) self.feid = int(self.satfinder_scan_nims.value) self.satList = [] self.scan_satselection = [] for slot in nimmanager.nim_slots: if slot.isCompatible("DVB-S"): self.satList.append(nimmanager.getSatListForNim(slot.slot)) self.scan_satselection.append(getConfigSatlist(self.orbital_position, self.satList[slot.slot])) else: self.satList.append(None) if self.frontendData: ttype = self.frontendData.get("tuner_type", "UNKNOWN") if ttype == "DVB-S" and self.predefinedTranspondersList(self.getSelectedSatIndex(self.feid)) is None and len(nimmanager.getTransponders(self.getSelectedSatIndex(self.feid))) > 0: self.tuning_type.value = "single_transponder" elif ttype == "DVB-T" and self.predefinedTerrTranspondersList() is None and len(nimmanager.getTranspondersTerrestrial(nimmanager.getTerrestrialDescription(self.feid))) > 0: self.tuning_type.value = "single_transponder" elif ttype == "DVB-C" and self.predefinedCabTranspondersList() is None and len(nimmanager.getTranspondersCable(self.feid)) > 0: self.tuning_type.value = "single_transponder"
def __init__(self, session): Screen.__init__(self, session) self['infoL'] = Label(_('Please Wait ... Starting Kodi Media Center')) self['actions'] = ActionMap(['OkCancelActions', 'ColorActions', 'DirectionActions'], {'ok': self.KeyOk}, -1) self.current_service = self.session.nav.getCurrentlyPlayingServiceReference() selectable_nims = [] for nim in nimmanager.nim_slots: if nim.config_mode == 'nothing': continue if nim.config_mode == 'advanced' and len(nimmanager.getSatListForNim(nim.slot)) < 1: continue if nim.config_mode in ('loopthrough', 'satposdepends'): root_id = nimmanager.sec.getRoot(nim.slot_id, int(nim.config.connectedTo.value)) if nim.type == nimmanager.nim_slots[root_id].type: continue if nim.isCompatible('DVB-S'): selectable_nims.append((str(nim.slot), nim.friendly_full_description)) self.select_nim = ConfigSelection(choices=selectable_nims) self.feid = 0 if self.select_nim.value != '': self.feid = int(self.select_nim.value) self.frontend = self.OpenFrontend() if self.frontend is None: self.oldref = self.session.nav.getCurrentlyPlayingServiceReference() self.session.nav.stopService() if not self.frontend: if session.pipshown: session.pipshown = False del session.pip if not self.openFrontend(): self.frontend = None self.session.nav.playService(None) self.KeyOk() return
def updateSatList(self): self.satList = [] for slot in nimmanager.nim_slots: if slot.isCompatible("DVB-S"): self.satList.append(nimmanager.getSatListForNim(slot.slot)) else: self.satList.append(None)
def SatfinderMain(session, close=None, **kwargs): nims = nimmanager.getNimListOfType("DVB-S") nimList = [] for x in nims: if nimmanager.getNimConfig(x).configMode.value in ("loopthrough", "satposdepends", "nothing"): continue if nimmanager.getNimConfig(x).configMode.value == "advanced" and len( nimmanager.getSatListForNim(x)) < 1: continue nimList.append(x) if len(nimList) == 0: session.open( MessageBox, _("No satellites configured. Plese check your tuner setup."), MessageBox.TYPE_ERROR) else: if session.nav.RecordTimer.isRecording(): session.open( MessageBox, _("A recording is currently running. Please stop the recording before trying to start the satfinder." ), MessageBox.TYPE_ERROR) else: session.openWithCallback(close, Satfinder)
def createConfig(self, foo): self.tuning_type = ConfigSelection(default = "predefined_transponder", choices = [("single_transponder", _("User defined transponder")), ("predefined_transponder", _("Predefined transponder"))]) self.orbital_position = 192 if self.frontendData and 'orbital_position' in self.frontendData: self.orbital_position = self.frontendData['orbital_position'] ScanSetup.createConfig(self, self.frontendData) # The following are updated in self.newConfig(). Do not add here. # self.scan_sat.system, self.tuning_type, self.scan_input_as, self.scan_ats.system, self.DVB_type, self.scan_ter.system, self.satfinder_scan_nims, self.tuning_sat for x in (self.scan_sat.frequency, self.scan_sat.inversion, self.scan_sat.symbolrate, self.scan_sat.polarization, self.scan_sat.fec, self.scan_sat.pilot, self.scan_sat.fec_s2, self.scan_sat.fec, self.scan_sat.modulation, self.scan_sat.rolloff, self.scan_sat.is_id, self.scan_sat.pls_mode, self.scan_sat.pls_code, self.scan_sat.t2mi_plp_id, self.scan_sat.t2mi_pid, self.scan_ter.channel, self.scan_ter.frequency, self.scan_ter.inversion, self.scan_ter.bandwidth, self.scan_ter.fechigh, self.scan_ter.feclow, self.scan_ter.modulation, self.scan_ter.transmission, self.scan_ter.guard, self.scan_ter.hierarchy, self.scan_ter.plp_id, self.scan_cab.frequency, self.scan_cab.inversion, self.scan_cab.symbolrate, self.scan_cab.modulation, self.scan_cab.fec, self.scan_ats.frequency, self.scan_ats.modulation, self.scan_ats.inversion): x.addNotifier(self.retune, initial_call = False) satfinder_nim_list = [] for n in nimmanager.nim_slots: if not any([n.isCompatible(x) for x in "DVB-S", "DVB-T", "DVB-C", "ATSC"]): continue if n.config_mode in ("loopthrough", "satposdepends", "nothing"): continue if n.isCompatible("DVB-S") and n.config_mode == "advanced" and len(nimmanager.getSatListForNim(n.slot)) < 1: continue satfinder_nim_list.append((str(n.slot), n.friendly_full_description))
def prepare(self): self.providers = Providers().read() self.providers_configs = {} self.orbital_supported = [] # get supported orbital positions dvbs_nims = nimmanager.getNimListOfType("DVB-S") for nim in dvbs_nims: sats = nimmanager.getSatListForNim(nim) for sat in sats: if sat[0] not in self.orbital_supported: self.orbital_supported.append(sat[0]) # read providers configurations providers_tmp_configs = {} providers_tmp = config.plugins.RadioTimesEmulator.providers.value.split( "|") for provider_tmp in providers_tmp: provider_config = ProviderConfig(provider_tmp) if not provider_config.isValid(): continue if provider_config.getProvider() not in self.providers: continue if self.providers[provider_config.getProvider()]["transponder"][ "orbital_position"] not in self.orbital_supported: continue providers_tmp_configs[ provider_config.getProvider()] = provider_config # build providers configurations for provider in self.providers.keys(): self.providers_configs[provider] = ConfigYesNo( default=provider in providers_tmp_configs.keys())
def updateSatList(self): self.satList = [] for slot in nimmanager.nim_slots: if slot.isCompatible("DVB-S"): self.satList.append(nimmanager.getSatListForNim(slot.slot)) else: self.satList.append(None)
def SatfinderMain(session, close=None, **kwargs): nims = nimmanager.nim_slots nimList = [] for n in nims: if n.isMultiType(): if not (n.isCompatible("DVB-S") or n.isCompatible("DVB-T") or n.isCompatible("DVB-C") or n.isCompatible("ATSC")): continue else: if not (n.isCompatible("DVB-S") or n.isCompatible("DVB-T") or n.isCompatible("DVB-C") or n.isCompatible("ATSC")): continue if n.isCompatible("DVB-S") and n.config.dvbs.configMode.value in ( "loopthrough", "satposdepends", "nothing"): continue if n.isCompatible( "DVB-S" ) and n.config.dvbs.configMode.value == "advanced" and len( nimmanager.getSatListForNim(n.slot)) < 1: continue nimList.append(n) if len(nimList) == 0: session.open( MessageBox, _("No satellite, terrestrial or cable tuner is configured. Please check your tuner setup." ), MessageBox.TYPE_ERROR) else: session.openWithCallback(close, Satfinder)
def __init__(self, session): Screen.__init__(self, session) self.setup_title = _("Blindscan") Screen.setTitle(self, _(self.setup_title)) self.skinName = "Setup" self.session.postScanService = self.session.nav.getCurrentlyPlayingServiceReference() self.onChangedEntry = [ ] self["HelpWindow"] = Pixmap() self["HelpWindow"].hide() self["VKeyIcon"] = Boolean(False) self["description"] = Label("") self['footnote'] = Label("") self["status"] = StaticText() # update sat list self.satList = [] for slot in nimmanager.nim_slots: if slot.isCompatible("DVB-S"): self.satList.append(nimmanager.getSatListForNim(slot.slot)) else: self.satList.append(None) # make config self.createConfig() self.list = [] self.status = "" ConfigListScreen.__init__(self, self.list, session = session, on_change = self.changedEntry) if self.scan_nims.value != None and self.scan_nims.value != "" : self["actions"] = ActionMap(["ColorActions", "SetupActions", 'DirectionActions'], { "red": self.keyCancel, "green": self.keyGo, "ok": self.keyGo, "cancel": self.keyCancel, }, -2) self["key_red"] = StaticText(_("Exit")) self["key_green"] = StaticText(_("Scan")) self["introduction"] = Label(_("Press Green/OK to start the scan")) self.createSetup() else : self["actions"] = ActionMap(["ColorActions", "SetupActions", 'DirectionActions'], { "red": self.keyCancel, "green": self.keyNone, "ok": self.keyNone, "cancel": self.keyCancel, }, -2) self["key_red"] = StaticText(_("Exit")) self["key_green"] = StaticText(" ") self["introduction"] = Label(_("Please setup your tuner configuration.")) self.i2c_mapping_table = None self.nimSockets = self.ScanNimsocket() self.makeNimSocket() self.changedEntry()
def __init__(self, session): Screen.__init__(self, session) self.setup_title = _("Blindscan") Screen.setTitle(self, _(self.setup_title)) self.skinName = "Setup" self.session.postScanService = self.session.nav.getCurrentlyPlayingServiceReference() self.onChangedEntry = [ ] self["HelpWindow"] = Pixmap() self["HelpWindow"].hide() self["VKeyIcon"] = Boolean(False) self["description"] = Label("") self['footnote'] = Label("") self["status"] = StaticText() # update sat list self.satList = [] for slot in nimmanager.nim_slots: if slot.isCompatible("DVB-S"): self.satList.append(nimmanager.getSatListForNim(slot.slot)) else: self.satList.append(None) # make config self.createConfig() self.list = [] self.status = "" ConfigListScreen.__init__(self, self.list, session = session, on_change = self.changedEntry) if self.scan_nims.value != None and self.scan_nims.value != "" : self["actions"] = ActionMap(["ColorActions", "SetupActions", 'DirectionActions'], { "red": self.keyCancel, "green": self.keyGo, "ok": self.keyGo, "cancel": self.keyCancel, }, -2) self["key_red"] = StaticText(_("Exit")) self["key_green"] = StaticText(_("Scan")) self["introduction"] = Label(_("Press Green/OK to start the scan")) self.createSetup() else : self["actions"] = ActionMap(["ColorActions", "SetupActions", 'DirectionActions'], { "red": self.keyCancel, "green": self.keyNone, "ok": self.keyNone, "cancel": self.keyCancel, }, -2) self["key_red"] = StaticText(_("Exit")) self["key_green"] = StaticText(" ") self["introduction"] = Label(_("Please setup your tuner configuration.")) self.i2c_mapping_table = None self.nimSockets = self.ScanNimsocket() self.makeNimSocket() self.changedEntry()
def getNetworksForNim(self, nim): if nim.isCompatible("DVB-S"): networks = nimmanager.getSatListForNim(nim.slot) 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. else: # empty tuners provide no networks. networks = [ ] return networks
def getNetworksForNim(self, nim): if nim.isCompatible("DVB-S"): networks = nimmanager.getSatListForNim(nim.slot) elif not nim.empty: networks = [nim.type] # "DVB-C" or "DVB-T". TODO: separate networks for different C/T tuners, if we want to support that. else: # empty tuners provide no networks. networks = [] return networks
def readTransponderList(self): for sat in nimmanager.getSatListForNim(self.feid): for transponder in nimmanager.getTransponders(sat[0]): mytransponder = (transponder[1] / 1000, transponder[2] / 1000, transponder[3], transponder[4], transponder[7], sat[0], transponder[5], transponder[6], transponder[8], transponder[9], transponder[10], transponder[11], transponder[12]) self.analyseTransponder(mytransponder)
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 configured_sats = nimmanager.getSatListForNim(nim.slot) if len(configured_sats) == 0: return False return True return False
def showNim(self, nim): nimConfig = nimmanager.getNimConfig(nim.slot) if nim.isCompatible("DVB-S"): if nimConfig.configMode.value in ("loopthrough_internal", "loopthrough_external", "equal", "satposdepends", "nothing"): return False configured_sats = nimmanager.getSatListForNim(nim.slot) if len(configured_sats) == 0: return False return True return False
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[7], sat[0], transponder[5], transponder[6], transponder[8], transponder[9], transponder[10], transponder[11]) self.analyseTransponder(mytransponder)
def getNetworksForNim(self, nim): networks = [ ] if nim.isCompatible("DVB-S"): tmpnetworks = nimmanager.getSatListForNim(nim.slot) for x in tmpnetworks: if x[0] == 282: networks.append(x) else: # empty tuners provide no networks. networks = [ ] return networks
def getNetworksForNim(self, nim): networks = [] if nim.isCompatible("DVB-S"): tmpnetworks = nimmanager.getSatListForNim(nim.slot) for x in tmpnetworks: if x[0] == 282: networks.append(x) else: # empty tuners provide no networks. networks = [] return networks
def SatfinderMain(session, close=None, **kwargs): nims = nimmanager.nim_slots nimList = [] for n in nims: if not any([n.isCompatible(x) for x in "DVB-S", "DVB-T", "DVB-C", "ATSC"]): continue if n.config_mode in ("loopthrough", "satposdepends", "nothing"): continue if n.isCompatible("DVB-S") and n.config_mode in ("advanced", "simple") and len(nimmanager.getSatListForNim(n.slot)) < 1 and len(n.getTunerTypesEnabled()) < 2: continue nimList.append(n)
def saveAll(self): if self.nim.isCompatible("DVB-S"): # reset connectedTo to all choices to properly store the default value choices = [] nimlist = nimmanager.getNimListOfType("DVB-S", self.slotid) for id in nimlist: choices.append((str(id), nimmanager.getNimDescription(id))) self.nimConfig.connectedTo.setChoices(choices) # sanity check for empty sat list if self.nimConfig.configMode.value != "satposdepends" and len(nimmanager.getSatListForNim(self.slotid)) < 1: self.nimConfig.configMode.value = "nothing" for x in self["config"].list: x[1].save()
def saveAll(self): if self.nim.isCompatible("DVB-S"): # reset connectedTo to all choices to properly store the default value choices = [] nimlist = nimmanager.getNimListOfType("DVB-S", self.slotid) for id in nimlist: choices.append((str(id), nimmanager.getNimDescription(id))) self.nimConfig.connectedTo.setChoices(choices) # sanity check for empty sat list if self.nimConfig.configMode.value != "satposdepends" and len(nimmanager.getSatListForNim(self.slotid)) < 1: self.nimConfig.configMode.value = "nothing" for x in self["config"].list: x[1].save()
def __init__(self, session): Screen.__init__(self, session) self.current_play_service = self.session.nav.getCurrentlyPlayingServiceReference() # update sat list self.satList = [] for slot in nimmanager.nim_slots: if slot.isCompatible("DVB-S"): self.satList.append(nimmanager.getSatListForNim(slot.slot)) else: self.satList.append(None) # make config self.createConfig() self.list = [] self.status = "" ConfigListScreen.__init__(self, self.list) if self.scan_nims.value != None and self.scan_nims.value != "" : self["actions"] = ActionMap(["OkCancelActions", "ShortcutActions", "WizardActions", "ColorActions", "SetupActions", ], { "red": self.keyCancel, "green": self.keyGo, "blue":self.keyGoAll, "ok": self.keyGo, "cancel": self.keyCancel, }, -2) self["key_red"] = StaticText(_("Exit")) self["key_green"] = StaticText("Scan") self["key_blue"] = StaticText("Scan All") self["introduction"] = Label(_("Press Green/OK to start the scan")) self.createSetup() else : self["actions"] = ActionMap(["OkCancelActions", "ShortcutActions", "WizardActions", "ColorActions", "SetupActions", ], { "red": self.keyCancel, "green": self.keyNone, "blue":self.keyNone, "ok": self.keyNone, "cancel": self.keyCancel, }, -2) self["key_red"] = StaticText(_("Exit")) self["key_green"] = StaticText(" ") self["key_blue"] = StaticText(" ") self["introduction"] = Label(_("Please setup your tuner configuration.")) self.i2c_mapping_table = None self.nimSockets = self.ScanNimsocket() self.makeNimSocket()
def __init__(self, session): Screen.__init__(self, session) self.current_play_service = self.session.nav.getCurrentlyPlayingServiceReference() # update sat list self.satList = [] for slot in nimmanager.nim_slots: if slot.isCompatible("DVB-S"): self.satList.append(nimmanager.getSatListForNim(slot.slot)) else: self.satList.append(None) # make config self.createConfig() self.list = [] self.status = "" ConfigListScreen.__init__(self, self.list) if self.scan_nims.value != None and self.scan_nims.value != "" : self["actions"] = ActionMap(["OkCancelActions", "ShortcutActions", "WizardActions", "ColorActions", "SetupActions", ], { "red": self.keyCancel, "green": self.keyGo, "blue":self.keyGoAll, "ok": self.keyGo, "cancel": self.keyCancel, }, -2) self["key_red"] = StaticText(_("Exit")) self["key_green"] = StaticText(_("Scan")) self["key_blue"] = StaticText(_("Scan All")) self["introduction"] = Label(_("Press Green/OK to start the scan")) self.createSetup() else : self["actions"] = ActionMap(["OkCancelActions", "ShortcutActions", "WizardActions", "ColorActions", "SetupActions", ], { "red": self.keyCancel, "green": self.keyNone, "blue":self.keyNone, "ok": self.keyNone, "cancel": self.keyCancel, }, -2) self["key_red"] = StaticText(_("Exit")) self["key_green"] = StaticText(" ") self["key_blue"] = StaticText(" ") self["introduction"] = Label(_("Please setup your tuner configuration.")) self.i2c_mapping_table = None self.nimSockets = self.ScanNimsocket() self.makeNimSocket()
def createConfig(self, foo): self.tuning_transponder = None self.tuning_type = ConfigSelection(choices = [("manual_transponder", _("Manual transponder")), ("predefined_transponder", _("Predefined transponder"))]) self.tuning_sat = getConfigSatlist(192, nimmanager.getSatListForNim(self.feid)) ScanSetup.createConfig(self, None) self.updateSats() for x in (self.tuning_type, self.tuning_sat, self.scan_sat.frequency, self.scan_sat.inversion, self.scan_sat.symbolrate, self.scan_sat.polarization, self.scan_sat.fec, self.scan_sat.pilot, self.scan_sat.fec_s2, self.scan_sat.fec, self.scan_sat.modulation, self.scan_sat.rolloff, self.scan_sat.system): x.addNotifier(self.retune, initial_call = False)
def SatfinderMain(session, close = None, **kwargs): nims = nimmanager.getNimListOfType('DVB-S') nimList = [] for x in nims: if nimmanager.getNimConfig(x).configMode.value in ('loopthrough', 'satposdepends', 'nothing'): continue if nimmanager.getNimConfig(x).configMode.value == 'advanced' and len(nimmanager.getSatListForNim(x)) < 1: continue nimList.append(x) if len(nimList) == 0: session.open(MessageBox, _('No satellites configured. Plese check your tuner setup.'), MessageBox.TYPE_ERROR) else: session.openWithCallback(close, Satfinder)
def saveAll(self): if self.nim.isCompatible('DVB-S'): choices = [] nimlist = nimmanager.getNimListOfType('DVB-S', self.slotid) for id in nimlist: choices.append((str(id), nimmanager.getNimDescription(id))) self.nimConfig.connectedTo.setChoices(choices) if self.nimConfig.configMode.value != 'satposdepends' and len(nimmanager.getSatListForNim(self.slotid)) < 1: self.nimConfig.configMode.value = 'nothing' for x in self['config'].list: x[1].save() configfile.save()
def createConfig(self, foo): self.tuning_transponder = None self.tuning_type = ConfigSelection(choices = [("manual_transponder", _("Manual transponder")), ("predefined_transponder", _("Predefined transponder"))]) self.tuning_sat = getConfigSatlist(192, nimmanager.getSatListForNim(self.feid)) ScanSetup.createConfig(self, None) self.updateSats() for x in (self.tuning_type, self.tuning_sat, self.scan_sat.frequency, self.scan_sat.inversion, self.scan_sat.symbolrate, self.scan_sat.polarization, self.scan_sat.fec, self.scan_sat.pilot, self.scan_sat.fec_s2, self.scan_sat.fec, self.scan_sat.modulation, self.scan_sat.rolloff, self.scan_sat.system): x.addNotifier(self.retune, initial_call = False)
def SatfinderMain(session, close=None, **kwargs): nims = nimmanager.nim_slots nimList = [] for n in nims: if not (n.isCompatible("DVB-S") or n.isCompatible("DVB-T") or n.isCompatible("DVB-C")): continue if n.config_mode in ("loopthrough", "satposdepends", "nothing"): continue if n.isCompatible("DVB-S") and n.config_mode == "advanced" and len(nimmanager.getSatListForNim(n.slot)) < 1: continue nimList.append(n) if len(nimList) == 0: session.open(MessageBox, _("No satellite, terrestrial or cable tuner is configured. Please check your tuner setup."), MessageBox.TYPE_ERROR) else: session.openWithCallback(close, Satfinder)
def SatfinderMain(session, close=None, **kwargs): nims = nimmanager.nim_slots nimList = [] for n in nims: if not any( [n.isCompatible(x) for x in "DVB-S", "DVB-T", "DVB-C", "ATSC"]): continue if n.config_mode in ("loopthrough_internal", "loopthrough_external", "satposdepends", "nothing"): continue if n.isCompatible("DVB-S") and n.config_mode in ( "advanced", "simple") and len(nimmanager.getSatListForNim(n.slot)) < 1: config.Nims[n.slot].configMode.value = "nothing" config.Nims[n.slot].configMode.save() continue nimList.append(n)
def SatfinderMain(self): nims = nimmanager.getNimListOfType("DVB-S") nimList = [] for x in nims: if nimmanager.getNimConfig(x).configMode.value in ("loopthrough", "satposdepends", "nothing"): continue if nimmanager.getNimConfig(x).configMode.value == "advanced" and len(nimmanager.getSatListForNim(x)) < 1: continue nimList.append(x) if len(nimList) == 0: self.session.open(MessageBox, _("No satellites configured. Plese check your tuner setup."), MessageBox.TYPE_ERROR) else: if self.session.nav.RecordTimer.isRecording(): self.session.open(MessageBox, _("A recording is currently running. Please stop the recording before trying to start the satfinder."), MessageBox.TYPE_ERROR) else: self.session.open(Satfinder)
def saveAll(self): if self.nim.isCompatible("DVB-S"): # reset connectedTo to all choices to properly store the default value choices = [] nimlist = nimmanager.getNimListOfType("DVB-S", self.slotid) for id in nimlist: choices.append((str(id), nimmanager.getNimDescription(id))) self.nimConfig.connectedTo.setChoices(choices) # sanity check for empty sat list if self.nimConfig.configMode.value != "satposdepends" and len(nimmanager.getSatListForNim(self.slotid)) < 1: self.nimConfig.configMode.value = "nothing" if self.nim.isFBCRoot(): if SystemInfo["HasForceLNBOn"]: config.misc.forceLnbPower.save() if SystemInfo["HasForceToneburst"]: config.misc.forceToneBurst.save() for x in self["config"].list: x[1].save() configfile.save()
def SatfinderMain(session, close=None, **kwargs): nims = nimmanager.nim_slots nimList = [] for n in nims: if not any([n.isCompatible(x) for x in ("DVB-S", "DVB-T", "DVB-C", "ATSC")]): continue if n.config_mode in ("loopthrough", "satposdepends", "nothing"): continue if n.isCompatible("DVB-S") and n.config_mode in ("advanced", "simple") and len(nimmanager.getSatListForNim(n.slot)) < 1 and len(n.getTunerTypesEnabled()) < 2: continue nimList.append(n) if len(nimList) == 0: session.open(MessageBox, _("No satellite, terrestrial or cable tuner is configured. Please check your tuner setup."), MessageBox.TYPE_ERROR) else: if dvbreader_available: session.openWithCallback(boundFunction(SatfinderCallback, close), SatfinderExtra) else: session.openWithCallback(boundFunction(SatfinderCallback, close), Satfinder)
def saveAll(self): if self.nim.isCompatible("DVB-S"): # reset connectedTo to all choices to properly store the default value choices = [] nimlist = nimmanager.getNimListOfType("DVB-S", self.slotid) for id in nimlist: choices.append((str(id), nimmanager.getNimDescription(id))) self.nimConfig.connectedTo.setChoices(choices) # sanity check for empty sat list if self.nimConfig.configMode.value != "satposdepends" and len(nimmanager.getSatListForNim(self.slotid)) < 1: self.nimConfig.configMode.value = "nothing" if self.nim.isFBCRoot(): if SystemInfo["HasForceLNBOn"]: config.misc.forceLnbPower.save() if SystemInfo["HasForceToneburst"]: config.misc.forceToneBurst.save() for x in self["config"].list: x[1].save() configfile.save()
def SatfinderMain(session, close=None, **kwargs): nims = nimmanager.getNimListOfType('DVB-S') nimList = [] for x in nims: if nimmanager.getNimConfig(x).configMode.value in ('loopthrough', 'satposdepends', 'nothing'): continue if nimmanager.getNimConfig(x).configMode.value == 'advanced' and len( nimmanager.getSatListForNim(x)) < 1: continue nimList.append(x) if len(nimList) == 0: session.open( MessageBox, _('No satellites configured. Plese check your tuner setup.'), MessageBox.TYPE_ERROR) else: session.openWithCallback(close, Satfinder)
def createConfig(self, foo): self.tuning_transponder = None self.tuning_type = ConfigSelection(choices = [("manual_transponder", _("Manual transponder")), ("predefined_transponder", _("Predefined transponder"))]) self.tuning_sat = getConfigSatlist(192, nimmanager.getSatListForNim(self.feid)) ScanSetup.createConfig(self, None) self.updateSats() setup_list = [self.tuning_type, self.tuning_sat, self.scan_sat.frequency, self.scan_sat.inversion, self.scan_sat.symbolrate, self.scan_sat.polarization, self.scan_sat.fec, self.scan_sat.pilot, self.scan_sat.fec_s2, self.scan_sat.fec, self.scan_sat.modulation, self.scan_sat.rolloff, self.scan_sat.system, self.scan_sat.is_id_bool, self.scan_sat.is_id, self.scan_sat.pls_mode, self.scan_sat.pls_code] nim = nimmanager.nim_slots[self.feid] if nim.isCompatible("DVB-S2X"): dvbs2x_setup_list = [self.scan_sat.system_dvbs2x, self.scan_sat.modulation_dvbs2x, self.scan_sat.fec_s2x_qpsk, self.scan_sat.fec_s2x_8psk, self.scan_sat.fec_s2x_8apsk, self.scan_sat.fec_s2x_16apsk, self.scan_sat.fec_s2x_32apsk] setup_list.extend(dvbs2x_setup_list) for x in setup_list: x.addNotifier(self.retune, initial_call = False)
def createConfig(self, foo): self.tuning_transponder = None self.tuning_type = ConfigSelection( choices=[("manual_transponder", _("Manual transponder") ), ("predefined_transponder", _("Predefined transponder"))]) orb_pos = 192 if foo is not None: orb_pos = foo.get("orbital_position", 192) self.tuning_sat = getConfigSatlist( orb_pos, nimmanager.getSatListForNim(self.feid)) ScanSetup.createConfig(self, foo) self.updateSats() for x in (self.tuning_sat, self.scan_sat.frequency, self.scan_sat.inversion, self.scan_sat.symbolrate, self.scan_sat.polarization, self.scan_sat.fec, self.scan_sat.fec_s2_8psk, self.scan_sat.fec_s2_8psk_auto, self.scan_sat.fec_s2_qpsk, self.scan_sat.fec_s2_qpsk_auto, self.scan_sat.modulation, self.scan_sat.modulation_auto, self.scan_sat.enable_mis, self.scan_sat.is_id, self.scan_sat.pls_mode, self.scan_sat.pls_code, self.scan_sat.pilot, self.scan_sat.rolloff): x.addNotifier(self.retune, initial_call=False)
def doTune(self): from Screens.Standby import inStandby if self.providers[self.currentAction]["streamtype"] == "dvbs": transponder = self.providers[self.currentAction]["transponder"] else: bouquet_key = None providers_tmp = config.autobouquetsmaker.providers.value.split("|") for provider_tmp in providers_tmp: provider_config = ProviderConfig(provider_tmp) provider_key = provider_config.getProvider() if self.currentAction != provider_key: continue bouquet_key = provider_config.getArea() if not bouquet_key: print>>log, "[AutoBouquetsMaker] No area found" self.showError(_('No area found')) return transponder = self.providers[self.currentAction]["bouquets"][bouquet_key] nimList = [] for nim in nimmanager.nim_slots: if (self.providers[self.currentAction]["streamtype"] == "dvbs" and nim.isCompatible("DVB-S") and nim.config_mode not in ("loopthrough")) or (self.providers[self.currentAction]["streamtype"] == "dvbc" and nim.isCompatible("DVB-C")) or (self.providers[self.currentAction]["streamtype"] == "dvbt" and nim.isCompatible("DVB-T")): nimList.append(nim.slot) if len(nimList) == 0: print>>log, "[AutoBouquetsMaker] No NIMs found" self.showError(_('No NIMs found')) return resmanager = eDVBResourceManager.getInstance() if not resmanager: print>>log, "[AutoBouquetsMaker] Cannot retrieve Resource Manager instance" self.showError(_('Cannot retrieve Resource Manager instance')) return if self.providers[self.currentAction]["streamtype"] == "dvbs": print>>log, "[AutoBouquetsMaker] Search NIM for orbital position %d" % transponder["orbital_position"] else: print>>log, "[AutoBouquetsMaker] Search NIM" current_slotid = -1 if self.rawchannel: del(self.rawchannel) self.frontend = None self.rawchannel = None nimList.reverse() # start from the last for slotid in nimList: if self.providers[self.currentAction]["streamtype"] == "dvbs": sats = nimmanager.getSatListForNim(slotid) for sat in sats: if sat[0] == transponder["orbital_position"]: if current_slotid == -1: # mark the first valid slotid in case of no other one is free current_slotid = slotid self.rawchannel = resmanager.allocateRawChannel(slotid) if self.rawchannel: print>>log, "[AutoBouquetsMaker] Nim found on slot id %d with sat %s" % (slotid, sat[1]) current_slotid = slotid break else: if current_slotid == -1: # mark the first valid slotid in case of no other one is free current_slotid = slotid self.rawchannel = resmanager.allocateRawChannel(slotid) if self.rawchannel: print>>log, "[AutoBouquetsMaker] Nim found on slot id %d" % (slotid) current_slotid = slotid break if self.rawchannel: break if current_slotid == -1: print>>log, "[AutoBouquetsMaker] No valid NIM found" self.showError(_('No valid NIM found')) return if not self.rawchannel: print>>log, "[AutoBouquetsMaker] Nim found on slot id %d but it's busy. Stop current service" % current_slotid if self.session.nav.RecordTimer.isRecording(): print>>log, "[AutoBouquetsMaker] Cannot free NIM because a record is in progress" self.showError(_('Cannot free NIM because a record is in progress')) return self.postScanService = self.session.nav.getCurrentlyPlayingServiceReference() self.session.nav.stopService() if self.session.pipshown: self.session.pipshown = False self.rawchannel = resmanager.allocateRawChannel(current_slotid) if not self.rawchannel: print>>log, "[AutoBouquetsMaker] Cannot get the NIM" self.showError(_('Cannot get the NIM')) return self.frontend = self.rawchannel.getFrontend() if not self.frontend: print>>log, "[AutoBouquetsMaker] Cannot get frontend" self.showError(_('Cannot get frontend')) return demuxer_id = self.rawchannel.reserveDemux() if demuxer_id < 0: print>>log, "[AutoBouquetsMaker] Cannot allocate the demuxer" self.showError(_('Cannot allocate the demuxer')) return if self.providers[self.currentAction]["streamtype"] == "dvbs": params = eDVBFrontendParametersSatellite() params.frequency = transponder["frequency"] params.symbol_rate = transponder["symbol_rate"] params.polarisation = transponder["polarization"] params.fec = transponder["fec_inner"] params.inversion = transponder["inversion"] params.orbital_position = transponder["orbital_position"] params.system = transponder["system"] params.modulation = transponder["modulation"] params.rolloff = transponder["roll_off"] params.pilot = transponder["pilot"] params_fe = eDVBFrontendParameters() params_fe.setDVBS(params, False) elif self.providers[self.currentAction]["streamtype"] == "dvbt": params = eDVBFrontendParametersTerrestrial() params.frequency = transponder["frequency"] params.bandwidth = transponder["bandwidth"] params.code_rate_hp = transponder["code_rate_hp"] params.code_rate_lp = transponder["code_rate_lp"] params.inversion = transponder["inversion"] params.system = transponder["system"] params.modulation = transponder["modulation"] params.transmission_mode = transponder["transmission_mode"] params.guard_interval = transponder["guard_interval"] params.hierarchy = transponder["hierarchy"] params_fe = eDVBFrontendParameters() params_fe.setDVBT(params) elif self.providers[self.currentAction]["streamtype"] == "dvbc": params = eDVBFrontendParametersCable() params.frequency = transponder["frequency"] params.symbol_rate = transponder["symbol_rate"] params.fec_inner = transponder["fec_inner"] params.inversion = transponder["inversion"] params.modulation = transponder["modulation"] params_fe = eDVBFrontendParameters() params_fe.setDVBC(params) self.rawchannel.requestTsidOnid() self.frontend.tune(params_fe) self.manager.setAdapter(0) # FIX: use the correct device self.manager.setDemuxer(demuxer_id) self.manager.setFrontend(current_slotid) self.lockcounter = 0 self.locktimer = eTimer() self.locktimer.callback.append(self.checkTunerLock) self.locktimer.start(100, 1)
def doTune(self): from Screens.Standby import inStandby if self.providers[self.currentAction]["streamtype"] == "dvbs": transponder = self.providers[self.currentAction]["transponder"] else: bouquet_key = None providers_tmp = config.autobouquetsmaker.providers.value.split("|") for provider_tmp in providers_tmp: provider_config = ProviderConfig(provider_tmp) provider_key = provider_config.getProvider() if self.currentAction != provider_key: continue bouquet_key = provider_config.getArea() if not bouquet_key: print >> log, "[AutoBouquetsMaker] No area found" self.showError(_('No area found')) return transponder = self.providers[ self.currentAction]["bouquets"][bouquet_key] nimList = [] for nim in nimmanager.nim_slots: if (nim.config_mode not in ("loopthrough", "satposdepends", "nothing")) and ( (self.providers[self.currentAction]["streamtype"] == "dvbs" and nim.isCompatible("DVB-S")) or (self.providers[self.currentAction]["streamtype"] == "dvbc" and nim.isCompatible("DVB-C")) or (self.providers[self.currentAction]["streamtype"] == "dvbt" and nim.isCompatible("DVB-T"))): nimList.append(nim.slot) if len(nimList) == 0: print >> log, "[AutoBouquetsMaker] No NIMs found" self.showError(_('No NIMs found')) return resmanager = eDVBResourceManager.getInstance() if not resmanager: print >> log, "[AutoBouquetsMaker] Cannot retrieve Resource Manager instance" self.showError(_('Cannot retrieve Resource Manager instance')) return if self.providers[self.currentAction]["streamtype"] == "dvbs": print >> log, "[AutoBouquetsMaker] Search NIM for orbital position %d" % transponder[ "orbital_position"] else: print >> log, "[AutoBouquetsMaker] Search NIM" # stop pip if running if self.session.pipshown: self.session.pipshown = False del self.session.pip print >> log, "[AutoBouquetsMaker] Stopping PIP." # stop currently playing service if it is using a tuner in ("loopthrough", "satposdepends") currentlyPlayingNIM = None currentService = self.session and self.session.nav.getCurrentService() frontendInfo = currentService and currentService.frontendInfo() frontendData = frontendInfo and frontendInfo.getAll(True) if frontendData is not None: currentlyPlayingNIM = frontendData.get("tuner_number", None) if self.providers[self.currentAction][ "streamtype"] == "dvbs" and currentlyPlayingNIM is not None: nimConfigMode = nimmanager.nim_slots[ currentlyPlayingNIM].config_mode if nimConfigMode in ("loopthrough", "satposdepends"): self.postScanService = self.session.nav.getCurrentlyPlayingServiceReference( ) self.session.nav.stopService() currentlyPlayingNIM = None print >> log, "[AutoBouquetsMaker] The active service was using a %s tuner, so had to be stopped (slot id %s)." % ( nimConfigMode, currentlyPlayingNIM) del frontendInfo del currentService current_slotid = -1 if self.rawchannel: del (self.rawchannel) self.frontend = None self.rawchannel = None nimList.reverse() # start from the last for slotid in nimList: if self.providers[self.currentAction]["streamtype"] == "dvbs": sats = nimmanager.getSatListForNim(slotid) for sat in sats: if sat[0] == transponder["orbital_position"]: if current_slotid == -1: # mark the first valid slotid in case of no other one is free current_slotid = slotid self.rawchannel = resmanager.allocateRawChannel(slotid) if self.rawchannel: print >> log, "[AutoBouquetsMaker] Nim found on slot id %d with sat %s" % ( slotid, sat[1]) current_slotid = slotid break else: if current_slotid == -1: # mark the first valid slotid in case of no other one is free current_slotid = slotid self.rawchannel = resmanager.allocateRawChannel(slotid) if self.rawchannel: print >> log, "[AutoBouquetsMaker] Nim found on slot id %d" % ( slotid) current_slotid = slotid break if self.rawchannel: break if current_slotid == -1: print >> log, "[AutoBouquetsMaker] No valid NIM found" self.showError(_('No valid NIM found')) return if not self.rawchannel: # if we are here the only possible option is to close the active service if currentlyPlayingNIM in nimList: slotid = currentlyPlayingNIM if self.providers[self.currentAction]["streamtype"] == "dvbs": sats = nimmanager.getSatListForNim(currentlyPlayingNIM) for sat in sats: if sat[0] == transponder["orbital_position"]: print >> log, "[AutoBouquetsMaker] Nim found on slot id %d but it's busy. Stopping active service" % currentlyPlayingNIM self.postScanService = self.session.nav.getCurrentlyPlayingServiceReference( ) self.session.nav.stopService() self.rawchannel = resmanager.allocateRawChannel( slotid) break else: print >> log, "[AutoBouquetsMaker] Nim found on slot id %d but it's busy. Stopping active service" % currentlyPlayingNIM self.postScanService = self.session.nav.getCurrentlyPlayingServiceReference( ) self.session.nav.stopService() self.rawchannel = resmanager.allocateRawChannel(slotid) if not self.rawchannel: if self.session.nav.RecordTimer.isRecording(): print >> log, "[AutoBouquetsMaker] Cannot free NIM because a record is in progress" self.showError( _('Cannot free NIM because a recording is in progress') ) return else: print >> log, "[AutoBouquetsMaker] Cannot get the NIM" self.showError(_('Cannot get the NIM')) return # set extended timeout for rotors if self.providers[self.currentAction][ "streamtype"] == "dvbs" and self.isRotorSat( slotid, transponder["orbital_position"]): self.LOCK_TIMEOUT = self.LOCK_TIMEOUT_ROTOR print >> log, "[AutoBouquetsMaker] Motorised dish. Will wait up to %i seconds for tuner lock." % ( self.LOCK_TIMEOUT / 10) else: self.LOCK_TIMEOUT = self.LOCK_TIMEOUT_FIXED print >> log, "[AutoBouquetsMaker] Fixed dish. Will wait up to %i seconds for tuner lock." % ( self.LOCK_TIMEOUT / 10) self.frontend = self.rawchannel.getFrontend() if not self.frontend: print >> log, "[AutoBouquetsMaker] Cannot get frontend" self.showError(_('Cannot get frontend')) return demuxer_id = self.rawchannel.reserveDemux() if demuxer_id < 0: print >> log, "[AutoBouquetsMaker] Cannot allocate the demuxer" self.showError(_('Cannot allocate the demuxer')) return if self.providers[self.currentAction]["streamtype"] == "dvbs": params = eDVBFrontendParametersSatellite() params.frequency = transponder["frequency"] params.symbol_rate = transponder["symbol_rate"] params.polarisation = transponder["polarization"] params.fec = transponder["fec_inner"] params.inversion = transponder["inversion"] params.orbital_position = transponder["orbital_position"] params.system = transponder["system"] params.modulation = transponder["modulation"] params.rolloff = transponder["roll_off"] params.pilot = transponder["pilot"] params_fe = eDVBFrontendParameters() params_fe.setDVBS(params, False) elif self.providers[self.currentAction]["streamtype"] == "dvbt": params = eDVBFrontendParametersTerrestrial() params.frequency = transponder["frequency"] params.bandwidth = transponder["bandwidth"] params.code_rate_hp = transponder["code_rate_hp"] params.code_rate_lp = transponder["code_rate_lp"] params.inversion = transponder["inversion"] params.system = transponder["system"] params.modulation = transponder["modulation"] params.transmission_mode = transponder["transmission_mode"] params.guard_interval = transponder["guard_interval"] params.hierarchy = transponder["hierarchy"] params_fe = eDVBFrontendParameters() params_fe.setDVBT(params) elif self.providers[self.currentAction]["streamtype"] == "dvbc": params = eDVBFrontendParametersCable() params.frequency = transponder["frequency"] params.symbol_rate = transponder["symbol_rate"] params.fec_inner = transponder["fec_inner"] params.inversion = transponder["inversion"] params.modulation = transponder["modulation"] params_fe = eDVBFrontendParameters() params_fe.setDVBC(params) self.rawchannel.requestTsidOnid() self.frontend.tune(params_fe) self.manager.setAdapter(0) # FIX: use the correct device self.manager.setDemuxer(demuxer_id) self.manager.setFrontend(current_slotid) self.lockcounter = 0 self.locktimer = eTimer() self.locktimer.callback.append(self.checkTunerLock) self.locktimer.start(100, 1)
def createConfig(self, frontendData): 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 } if frontendData is not None: ttype = frontendData.get("tuner_type", "UNKNOWN") if ttype == "DVB-S": 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) defaultSat["modulation"] = frontendData.get("modulation", eDVBFrontendParametersSatellite.Modulation_QPSK) 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"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto) defaultSat["orbpos"] = frontendData.get("orbital_position", 0) self.scan_sat = ConfigSubsection() 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 = [] for n in nimmanager.nim_slots: if hasattr(n, 'isFBCLink') and n.isFBCLink(): continue if n.config_mode == "nothing": continue if n.isCompatible("DVB-S") and len(nimmanager.getSatListForNim(n.slot)) < 1: if n.config_mode in ("advanced", "simple"): config.Nims[n.slot].configMode.value = "nothing" config.Nims[n.slot].configMode.save() 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 if n.isCompatible("DVB-S"): nim_list.append((str(n.slot), n.friendly_full_description)) self.scan_nims = ConfigSelection(choices = nim_list) self.scan_sat.bs_system = ConfigSelection(default = eDVBFrontendParametersSatellite.System_DVB_S2, choices = [ (eDVBFrontendParametersSatellite.System_DVB_S2, _("DVB-S + DVB-S2")), (eDVBFrontendParametersSatellite.System_DVB_S, _("DVB-S only"))]) self.scan_sat.bs_accuracy = ConfigSelection(default = 2, choices = [ (1, "1"), (2, "2"), (3, "3"), (4, "4"), (5, "5")]) self.search_type = ConfigSelection(default = 0, choices = [ (0, _("scan for channels")), (1, _("save to XML file"))]) self.scan_sat.bs_horizontal = ConfigYesNo(default = True) self.scan_sat.bs_vertical = ConfigYesNo(default = True) self.nim_sat_frequency_range = [] self.nim_sat_band_cutoff_frequency = [] self.scan_satselection = [] for slot in nimmanager.nim_slots: slot_id = slot.slot if slot.isCompatible("DVB-S"): satlist_for_slot = self.satList[slot_id] self.scan_satselection.append(getConfigSatlist(defaultSat["orbpos"], satlist_for_slot)) sat_freq_range = {(10700000, 12750000) } sat_band_cutoff = {11700000 } for sat in satlist_for_slot: orbpos = sat[0] self.nim_sat_frequency_range.append(sat_freq_range) self.nim_sat_band_cutoff_frequency.append(sat_band_cutoff) else: self.nim_sat_frequency_range.append(None) self.nim_sat_band_cutoff_frequency.append(None) self.scan_satselection.append(None) return True
def updateList(self, index=None): self.list = [ ] for x in nimmanager.nim_slots: slotid = x.slot nimConfig = nimmanager.getNimConfig(x.slot) text = nimConfig.configMode.value if self.showNim(x): if x.isCompatible("DVB-S"): if nimConfig.configMode.value in ("loopthrough", "equal", "satposdepends"): if x.isFBCLink(): text = _("FBC automatic\nconnected to") else: text = { "loopthrough": _("Loop through from"), "equal": _("Equal to"), "satposdepends": _("Second cable of motorized LNB") } [nimConfig.configMode.value] text += " " + nimmanager.getNim(int(nimConfig.connectedTo.value)).slot_name elif nimConfig.configMode.value == "nothing": if x.isFBCLink(): link = getLinkedSlotID(x.slot) if link == -1: text = _("FBC automatic\ninactive") else: link = nimmanager.getNim(link).slot_name text = _("FBC automatic\nconnected to %s") % link else: text = _("not configured") elif nimConfig.configMode.value == "simple": if nimConfig.diseqcMode.value in ("single", "toneburst_a_b", "diseqc_a_b", "diseqc_a_b_c_d"): text = {"single": _("Single"), "toneburst_a_b": _("Toneburst A/B"), "diseqc_a_b": _("DiSEqC A/B"), "diseqc_a_b_c_d": _("DiSEqC A/B/C/D")}[nimConfig.diseqcMode.value] + "\n" text += _("Sats") + ": " satnames = [] if nimConfig.diseqcA.orbital_position < 3600: satnames.append(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 < 3600: satnames.append(nimmanager.getSatName(int(nimConfig.diseqcB.value))) if nimConfig.diseqcMode.value == "diseqc_a_b_c_d": if nimConfig.diseqcC.orbital_position < 3600: satnames.append(nimmanager.getSatName(int(nimConfig.diseqcC.value))) if nimConfig.diseqcD.orbital_position < 3600: satnames.append(nimmanager.getSatName(int(nimConfig.diseqcD.value))) if len(satnames) <= 2: text += ", ".join(satnames) elif len(satnames) > 2: # we need a newline here, since multi content lists don't support automtic line wrapping text += ", ".join(satnames[:2]) + ",\n" text += " " + ", ".join(satnames[2:]) elif nimConfig.diseqcMode.value in ("positioner", "positioner_select"): text = {"positioner": _("Positioner"), "positioner_select": _("Positioner (selecting satellites)")}[nimConfig.diseqcMode.value] text += ": " if nimConfig.positionerMode.value == "usals": text += "USALS" elif nimConfig.positionerMode.value == "manual": text += _("Manual") else: text = _("Simple") elif nimConfig.configMode.value == "advanced": text = _("Advanced") + "\n" text += _("Sats") + ": " satnames = [] for sat in nimmanager.getSatListForNim(slotid): satnames.append(self.OrbToStr(int(sat[0]))) text += ", ".join(satnames) elif x.isCompatible("DVB-T") or x.isCompatible("DVB-C") or x.isCompatible("ATSC"): if nimConfig.configMode.value == "nothing": text = _("Nothing connected") elif nimConfig.configMode.value == "enabled": text = _("Enabled") if x.isMultiType(): text = _("Switchable tuner types:") + " (" + ','.join(x.getMultiTypeList().values()) + ")" + "\n" + text if not x.isSupported(): text = _("Tuner is not supported") self.list.append((slotid, x.friendly_full_description, text, x)) self["nimlist"].setList(self.list) self["nimlist"].updateList(self.list) if index is not None: self["nimlist"].setIndex(index)
def getNimListForSat(orb_pos): return [ nim.slot for nim in nimmanager.nim_slots if nim.isCompatible("DVB-S") and orb_pos in [sat[0] for sat in nimmanager.getSatListForNim(nim.slot)] ]
def createConfig(self, frontendData): 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, "system": eDVBFrontendParametersCable.System_DVB_C_ANNEX_A } defaultTer = { "frequency" : 474000, "inversion" : eDVBFrontendParametersTerrestrial.Inversion_Unknown, "bandwidth" : 8000000, "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"] = 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"] = 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"] = 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) defaultTer["system"] = frontendData.get("system", eDVBFrontendParametersCable.System_DVB_C_ANNEX_A) elif ttype == "DVB-T": defaultTer["frequency"] = frontendData.get("frequency", 0) defaultTer["inversion"] = frontendData.get("inversion", eDVBFrontendParametersTerrestrial.Inversion_Unknown) defaultTer["bandwidth"] = frontendData.get("bandwidth", 8000000) 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) self.scan_sat = ConfigSubsection() self.scan_cab = ConfigSubsection() self.scan_ter = ConfigSubsection() nim_list = [] # collect all nims which are *not* set to "nothing" for n in nimmanager.nim_slots: 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) if frontendData is not None and len(nim_list) > 0: self.scan_nims.value = str(frontendData.get("tuner_number", nim_list[0][0])) for slot in nimmanager.nim_slots: if slot.isCompatible("DVB-T"): self.ter_tnumber = slot.slot if self.ter_tnumber: self.ter_channel_input = channelnumbers.supportedChannels(self.ter_tnumber) # status self.scan_snr = ConfigSlider() self.scan_snr.enabled = False self.scan_agc = ConfigSlider() self.scan_agc.enabled = False self.scan_ber = ConfigSlider() self.scan_ber.enabled = False # sat 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 = [ (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 = [ (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"), (eDVBFrontendParametersSatellite.RollOff_auto, _("Auto"))]) 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 = [ (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_6_7, "6/7"), (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)) self.scan_cab.system = ConfigSelection(default = defaultCab["system"], choices = [ (eDVBFrontendParametersCable.System_DVB_C_ANNEX_A, _("DVB-C")), (eDVBFrontendParametersCable.System_DVB_C_ANNEX_C, _("DVB-C ANNEX C"))]) # terrestial self.scan_ter.frequency = ConfigInteger(default = 474000, limits = (50000, 999000)) self.scan_ter.channel = ConfigInteger(default = 21, limits = (1, 99)) 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 = defaultTer["bandwidth"], choices = [ (1712000, "1.712MHz"), (5000000, "5MHz"), (6000000, "6MHz"), (7000000, "7MHz"), (8000000, "8MHz"), (10000000,"10MHz") ]) #, (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_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_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_QAM256, "QAM256"), (eDVBFrontendParametersTerrestrial.Modulation_Auto, _("Auto"))]) self.scan_ter.transmission = 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_1_128, "1/128"), (eDVBFrontendParametersTerrestrial.GuardInterval_19_128, "19/128"), (eDVBFrontendParametersTerrestrial.GuardInterval_19_256, "19/256"), (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)) if frontendData is not None and ttype == "DVB-S" and self.predefinedTranspondersList(defaultSat["orbpos"]) != None: defaultSatSearchType = "predefined_transponder" else: defaultSatSearchType = "single_transponder" self.scan_type = ConfigSelection(default = defaultSatSearchType, choices = [("single_transponder", _("User defined transponder")), ("predefined_transponder", _("Predefined transponder")), ("single_satellite", _("Single satellite")), ("multisat", _("Multisat")), ("multisat_yes", _("Multisat all select"))]) 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_input_as = ConfigSelection(default = "channel", choices = [("frequency", _("Frequency")), ("channel", _("Channel"))]) 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) self.scan_scansat = {} for sat in nimmanager.satList: #print sat[1] self.scan_scansat[sat[0]] = ConfigYesNo(default = False) self.scan_satselection = [] for slot in nimmanager.nim_slots: if slot.isCompatible("DVB-S"): self.scan_satselection.append(getConfigSatlist(defaultSat["orbpos"], self.satList[slot.slot])) else: self.scan_satselection.append(None) return True
def createConfig(self, frontendData): #("Type", frontendData["system"], TYPE_TEXT), #("Modulation", frontendData["modulation"], TYPE_TEXT), #("Orbital position", frontendData["orbital_position"], TYPE_VALUE_DEC), #("Frequency", frontendData["frequency"], TYPE_VALUE_DEC), #("Symbolrate", frontendData["symbol_rate"], TYPE_VALUE_DEC), #("Polarization", frontendData["polarization"], TYPE_TEXT), #("Inversion", frontendData["inversion"], TYPE_TEXT), #("FEC inner", frontendData["fec_inner"], TYPE_TEXT), #) #elif frontendData["tuner_type"] == "DVB-C": #return ( ("NIM", ['A', 'B', 'C', 'D'][frontendData["tuner_number"]], TYPE_TEXT), #("Type", frontendData["tuner_type"], TYPE_TEXT), #("Frequency", frontendData["frequency"], TYPE_VALUE_DEC), #("Symbolrate", frontendData["symbol_rate"], TYPE_VALUE_DEC), #("Modulation", frontendData["modulation"], TYPE_TEXT), #("Inversion", frontendData["inversion"], TYPE_TEXT), # ("FEC inner", frontendData["fec_inner"], TYPE_TEXT), #) #elif frontendData["tuner_type"] == "DVB-T": #return ( ("NIM", ['A', 'B', 'C', 'D'][frontendData["tuner_number"]], TYPE_TEXT), #("Type", frontendData["tuner_type"], TYPE_TEXT), #("Frequency", frontendData["frequency"], TYPE_VALUE_DEC), #("Inversion", frontendData["inversion"], TYPE_TEXT), #("Bandwidth", frontendData["bandwidth"], TYPE_VALUE_DEC), #("CodeRateLP", frontendData["code_rate_lp"], TYPE_TEXT), #("CodeRateHP", frontendData["code_rate_hp"], TYPE_TEXT), #("Constellation", frontendData["constellation"], TYPE_TEXT), #("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": 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 } if frontendData is not None: ttype = frontendData.get("tuner_type", "UNKNOWN") if ttype == "DVB-S": 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"] = 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"] = 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) 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) 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")), ("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": 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) # status self.scan_snr = ConfigSlider() self.scan_snr.enabled = False self.scan_agc = ConfigSlider() self.scan_agc.enabled = False self.scan_ber = ConfigSlider() self.scan_ber.enabled = False # sat 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 = [ (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 = [ (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"), (eDVBFrontendParametersSatellite.RollOff_auto, _("Auto"))]) 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 = [ (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 = 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 = defaultTer["bandwidth"], choices = [ (eDVBFrontendParametersTerrestrial.Bandwidth_8MHz, "8MHz"), (eDVBFrontendParametersTerrestrial.Bandwidth_7MHz, "7MHz"), (eDVBFrontendParametersTerrestrial.Bandwidth_6MHz, "6MHz")]) #, (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.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.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.transmission = ConfigSelection(default = defaultTer["transmission_mode"], choices = [ (eDVBFrontendParametersTerrestrial.TransmissionMode_2k, "2K"), (eDVBFrontendParametersTerrestrial.TransmissionMode_8k, "8K"), (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.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_scansat = {} for sat in nimmanager.satList: #print sat[1] self.scan_scansat[sat[0]] = ConfigYesNo(default = False) self.scan_satselection = [] for slot in nimmanager.nim_slots: if slot.isCompatible("DVB-S"): self.scan_satselection.append(getConfigSatlist(defaultSat["orbpos"], self.satList[slot.slot])) else: self.scan_satselection.append(None) return True
def __init__(self, session): Screen.__init__(self, session) self.setup_title = _("Blind scan for internal DVB-S2 tuners") Screen.setTitle(self, _(self.setup_title)) self.skinName = "Blindscan" try: self.session.postScanService = self.session.nav.getCurrentlyPlayingServiceOrGroup() except: self.session.postScanService = self.session.nav.getCurrentlyPlayingServiceReference() self.onChangedEntry = [ ] self["description"] = Label("") self["rotorstatus"] = Label("") self.getCurrentTuner = None self.orb_pos = 0 # update sat list self.satList = [] for slot in nimmanager.nim_slots: if slot.isCompatible("DVB-S"): self.satList.append(nimmanager.getSatListForNim(slot.slot)) else: self.satList.append(None) self.statusTimer = eTimer() self.statusTimer.callback.append(self.setDishOrbosValue) # make config self.createConfig() self.list = [] ConfigListScreen.__init__(self, self.list, session = session, on_change = self.changedEntry) if self.scan_nims.value != None and self.scan_nims.value != "" : self["actions"] = ActionMap(["ColorActions", "SetupActions", 'DirectionActions'], { "red": self.keyCancel, "green": self.keyGo, "yellow": self.keyFile, "ok": self.keyGo, "cancel": self.keyCancel, }, -2) self["red"] = Label(_("Exit")) self["yellow"] = Label("") self["green"] = Label(_("Scan")) self["introduction"] = Label(_("Press Green/OK to start the scan")) self.createSetup() else : self["actions"] = ActionMap(["ColorActions", "SetupActions", 'DirectionActions'], { "red": self.keyCancel, "green": self.keyNone, "yellow": self.keyNone, "ok": self.keyNone, "cancel": self.keyCancel, }, -2) self["red"] = Label(_("Exit")) self["yellow"] = Label("") self["green"] = Label(" ") self["introduction"] = Label(_("Please setup your tuner configuration.")) self.i2c_mapping_table = None self.nimSockets = self.ScanNimsocket() self.makeNimSocket() self["config"].onSelectionChanged.append(self.textHelp) if XML_FILE is not None and os.path.exists(XML_FILE): self["yellow"].setText(_("Open xml file")) self.changedEntry()
def createSetup(self): self.list = [] self.multiscanlist = [] index_to_scan = int(self.scan_nims.value) print "ID: ", index_to_scan self.tunerEntry = getConfigListEntry(_("Tuner"), self.scan_nims) self.list.append(self.tunerEntry) if self.scan_nims == [ ]: return self.typeOfScanEntry = None self.typeOfInputEntry = None self.systemEntry = None self.modulationEntry = None self.preDefSatList = None nim = nimmanager.nim_slots[index_to_scan] if nim.isCompatible("DVB-S"): self.typeOfScanEntry = getConfigListEntry(_("Type of scan"), self.scan_type) self.list.append(self.typeOfScanEntry) elif nim.isCompatible("DVB-C"): self.typeOfScanEntry = getConfigListEntry(_("Type of scan"), self.scan_typecable) self.list.append(self.typeOfScanEntry) elif nim.isCompatible("DVB-T"): self.typeOfScanEntry = getConfigListEntry(_("Type of scan"), self.scan_typeterrestrial) self.typeOfInputEntry = getConfigListEntry(_("Use frequency or channel"), self.scan_input_as) self.list.append(self.typeOfScanEntry) if self.ter_channel_input: self.list.append(self.typeOfInputEntry) self.scan_networkScan.value = False if nim.isCompatible("DVB-S"): if self.scan_type.value == "single_transponder": self.updateSatList() if nim.isCompatible("DVB-S2"): self.systemEntry = getConfigListEntry(_('System'), self.scan_sat.system) self.list.append(self.systemEntry) else: # downgrade to dvb-s, in case a -s2 config was active 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(_('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 == 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(_('Roll-off'), self.scan_sat.rolloff)) self.list.append(getConfigListEntry(_('Pilot'), self.scan_sat.pilot)) elif self.scan_type.value == "predefined_transponder" and self.satList[index_to_scan]: self.updateSatList() self.preDefSatList = getConfigListEntry(_('Satellite'), self.scan_satselection[index_to_scan]) self.list.append(self.preDefSatList) sat = self.satList[index_to_scan][self.scan_satselection[index_to_scan].index] self.predefinedTranspondersList(sat[0]) self.list.append(getConfigListEntry(_('Transponder'), self.preDefTransponders)) 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.scan_networkScan.value = True elif "multisat" in self.scan_type.value: tlist = [] SatList = nimmanager.getSatListForNim(index_to_scan) for x in SatList: if self.Satexists(tlist, x[0]) == 0: tlist.append(x[0]) sat = ConfigEnableDisable(default = "_yes" in self.scan_type.value and True or False) configEntry = getConfigListEntry(nimmanager.getSatDescription(x[0]), sat) self.list.append(configEntry) self.multiscanlist.append((x[0], sat)) 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(_("Modulation"), self.scan_cab.modulation)) self.list.append(getConfigListEntry(_("FEC"), self.scan_cab.fec)) if config.Nims[index_to_scan].cable.scan_networkid.value: self.networkid = config.Nims[index_to_scan].cable.scan_networkid.value self.scan_networkScan.value = True elif nim.isCompatible("DVB-T"): if self.scan_typeterrestrial.value == "single_transponder": 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.ter_channel_input and self.scan_input_as.value == "channel": channel = channelnumbers.getChannelNumber(self.scan_ter.frequency.value*1000, self.ter_tnumber) self.scan_ter.channel.value = int(channel.replace("+","").replace("-","")) self.list.append(getConfigListEntry(_("Channel"), self.scan_ter.channel)) else: self.scan_ter.frequency.value = channelnumbers.channel2frequency(self.scan_ter.channel.value, self.ter_tnumber)/1000 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)) if self.scan_ter.system.value == eDVBFrontendParametersTerrestrial.System_DVB_T2: 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)
def __init__(self, isAutostart, session, args = 0): Screen.__init__(self, session) self.session = session self.Console = Console() self.current_service = self.session.nav.getCurrentlyPlayingServiceReference() selectable_nims = [] for nim in nimmanager.nim_slots: if nim.config_mode == 'nothing': continue if nim.config_mode == 'advanced' and len(nimmanager.getSatListForNim(nim.slot)) < 1: continue if nim.config_mode in ('loopthrough', 'satposdepends'): root_id = nimmanager.sec.getRoot(nim.slot_id, int(nim.config.connectedTo.value)) if nim.type == nimmanager.nim_slots[root_id].type: continue if nim.isCompatible('DVB-S'): selectable_nims.append((str(nim.slot), nim.friendly_full_description)) self.select_nim = ConfigSelection(choices=selectable_nims) self.feid = 0 if self.select_nim.value != '': self.feid = int(self.select_nim.value) self.frontend = self.OpenFrontend() if self.frontend is None: self.oldref = self.session.nav.getCurrentlyPlayingServiceReference() self.session.nav.stopService() if not self.frontend: if session.pipshown: session.pipshown = False del session.pip if not self.openFrontend(): self.frontend = None self.session.nav.playService(None) self.switchmode = 0 self.showhide = 0 self['menu'] = List([]) self['actions'] = NumberActionMap(['MediaPlayerActions', 'SetupActions', 'DirectionActions'], {'menu': self.Konfig, 'ok': self.ok, 'cancel': self.sakri, 'up': self.keyUp, 'down': self.keyDown, 'left': self.keyLeft, 'right': self.keyRight, 'nextBouquet': self.ZapUp, 'prevBouquet': self.ZapDown, '1': self.keyNumberGlobal, '2': self.keyNumberGlobal, '3': self.keyNumberGlobal, '4': self.keyNumberGlobal, '5': self.keyNumberGlobal, '6': self.keyNumberGlobal, '7': self.keyNumberGlobal, '8': self.keyNumberGlobal, '9': self.keyNumberGlobal, '0': self.keyNumberGlobal}, -2) self['text2'] = Label(_('Loading...Please Wait')) self['start_progress'] = ProgressBar() self['infoM0'] = Label() self['infoM1'] = Label() self['infoM2'] = Label() self['l001'] = Pixmap() self['l002'] = Pixmap() self['l003'] = Pixmap() self['l004'] = Pixmap() self['l005'] = Pixmap() self['l006'] = Pixmap() self['l007'] = Pixmap() self['l008'] = Pixmap() self['picon'] = Pixmap() self.TestCounter = 0 self.playstarted = False self.DVBCATimer = eTimer() self.DVBCATimer.callback.append(self.Prepare) buffersize = 512 try: myfile = file('/usr/lib/enigma2/python/Plugins/Extensions/AzIPTV/config') for line in myfile.readlines(): if line[0:1] != '#': ipos = ipos1 = 0 ipos = line.find('<buffersize>') ipos1 = line.find('</buffersize>') if ipos != '' and ipos1 != '' and ipos1 > ipos: buffersize = int(line[ipos + 12:ipos1]) except: print 'Error reading cfg file.' if buffersize < 128: buffersize = 128 hw_type = HardwareInfo().get_device_name() if hw_type == 'minime' or hw_type == 'me': self.cmd0 = 'rmfp_player -dram 0 -ve 0 -vd 0 -ae 0 -no_disp -prebuf ' if hw_type == 'elite' or hw_type == 'premium' or hw_type == 'premium+' or hw_type == 'ultra': self.cmd0 = 'rmfp_player -dram 1 -ve 1 -vd 0 -ae 0 -no_disp -prebuf ' self.cmd0 = self.cmd0 + str(buffersize) + ' -detect_limit 100 -resetvcxo -no_close -oscaler spu -nosubs ' self.showhide = 0 self['menu1'] = MenuList([]) self['menu'] = List([]) self.onLayoutFinish.append(self.startup)
def prepare(self): self.activityTimer.stop() self.providers = Manager().getProviders() self.providers_configs = {} self.providers_area = {} self.providers_swapchannels = {} self.providers_makemain = {} self.providers_custommain = {} self.providers_makesections = {} self.providers_makehd = {} self.providers_makefta = {} self.providers_makeftahd = {} self.providers_FTA_only = {} self.providers_order = [] self.orbital_supported = [] # make config test for ATV Multituner self.legacy = True for slot in nimmanager.nim_slots: if slot.canBeCompatible("DVB-S"): try: slot.config.dvbs self.legacy = False except: self.legacy = True break # get supported orbital positions dvbs_nims = nimmanager.getNimListOfType("DVB-S") for nim in dvbs_nims: sats = nimmanager.getSatListForNim(nim) for sat in sats: if sat[0] not in self.orbital_supported: self.orbital_supported.append(sat[0]) self.dvbc_nims = [] self.dvbt_nims = [] for nim in nimmanager.nim_slots: if not self.legacy: if nim.isCompatible("DVB-C") or (nim.isCompatible("DVB-S") and nim.canBeCompatible("DVB-C")): self.dvbc_nims.append(nim.slot) if nim.isCompatible("DVB-T") or (nim.isCompatible("DVB-S") and nim.canBeCompatible("DVB-T")): self.dvbt_nims.append(nim.slot) else: if nim.config_mode != "nothing": if nim.isCompatible("DVB-C") or (nim.isCompatible("DVB-S") and nim.canBeCompatible("DVB-C")): self.dvbc_nims.append(nim.slot) if nim.isCompatible("DVB-T") or (nim.isCompatible("DVB-S") and nim.canBeCompatible("DVB-T")): self.dvbt_nims.append(nim.slot) # dependent providers self.dependents_list = [] for provider_key in self.providers: if len(self.providers[provider_key]["dependent"]) > 0 and self.providers[provider_key]["dependent"] in self.providers: self.dependents_list.append(provider_key) # read providers configurations providers_tmp_configs = {} providers_tmp = config.autobouquetsmaker.providers.value.split("|") for provider_tmp in providers_tmp: provider_config = ProviderConfig(provider_tmp) if not provider_config.isValid(): continue if provider_config.getProvider() not in self.providers: continue if self.providers[provider_config.getProvider()]["streamtype"] == 'dvbs' and self.providers[provider_config.getProvider()]["transponder"]["orbital_position"] not in self.orbital_supported: continue if self.providers[provider_config.getProvider()]["streamtype"] == 'dvbc' and len(self.dvbc_nims) <= 0: continue if self.providers[provider_config.getProvider()]["streamtype"] == 'dvbt' and len(self.dvbt_nims) <= 0: continue self.providers_order.append(provider_config.getProvider()) providers_tmp_configs[provider_config.getProvider()] = provider_config # get current bouquets list (for custom main) bouquets = Manager().getBouquetsList() bouquets_list = [] if bouquets["tv"] is not None: for bouquet in bouquets["tv"]: if bouquet["filename"][:len(self.ABM_BOUQUET_PREFIX)] == self.ABM_BOUQUET_PREFIX: continue bouquets_list.append((bouquet["filename"], bouquet["name"])) # build providers configurations for provider in self.providers.keys(): self.providers_configs[provider] = ConfigYesNo(default = (provider not in self.dependents_list and provider in providers_tmp_configs.keys())) self.providers_swapchannels[provider] = ConfigYesNo(default = (provider in providers_tmp_configs and providers_tmp_configs[provider].isSwapChannels())) custom_bouquets_exists = False self.providers_makemain[provider] = None self.providers_custommain[provider] = None self.providers_makesections[provider] = None self.providers_makehd[provider] = None self.providers_makefta[provider] = None self.providers_makeftahd[provider] = None if len(self.providers[provider]["sections"].keys()) > 1: # only if there's more than one section sections_default = True if provider in providers_tmp_configs: sections_default = providers_tmp_configs[provider].isMakeSections() self.providers_makesections[provider] = ConfigYesNo(default = sections_default) custom_bouquets_exists = True if self.providers[provider]["protocol"] != "fastscan": # fastscan doesn't have enough information to make HD and/or FTA bouquets hd_default = True fta_default = True ftahd_default = True if provider in providers_tmp_configs: hd_default = providers_tmp_configs[provider].isMakeHD() fta_default = providers_tmp_configs[provider].isMakeFTA() ftahd_default = providers_tmp_configs[provider].isMakeFTAHD() self.providers_makehd[provider] = ConfigYesNo(default = hd_default) self.providers_makefta[provider] = ConfigYesNo(default = fta_default) self.providers_makeftahd[provider] = ConfigYesNo(default = ftahd_default) custom_bouquets_exists = True if sorted(self.providers[provider]["sections"].keys())[0] > 1: makemain_default = "no" makemain_list = [("yes", _("yes"))] if self.providers[provider]["protocol"] != "fastscan": makemain_list.append(("hd", _("yes (only HD)"))) makemain_list.append(("ftahd", _("yes (only FTA HD)"))) if provider not in providers_tmp_configs and self.providers[provider]["protocol"] == "sky": makemain_default = "ftahd" # FTA HD only as default elif provider not in providers_tmp_configs: makemain_default = "yes" # enabled as default if provider in providers_tmp_configs and providers_tmp_configs[provider].isMakeNormalMain(): makemain_default = "yes" if self.providers[provider]["protocol"] != "fastscan": if provider in providers_tmp_configs and providers_tmp_configs[provider].isMakeHDMain(): makemain_default = "hd" if provider in providers_tmp_configs and providers_tmp_configs[provider].isMakeFTAHDMain(): makemain_default = "ftahd" if len(bouquets_list) > 0 and config.autobouquetsmaker.placement.getValue() == 'top': makemain_list.append(("custom", _("yes (custom)"))) if provider in providers_tmp_configs and providers_tmp_configs[provider].isMakeCustomMain(): makemain_default = "custom" bouquet_default = bouquets_list[0][0] if provider in providers_tmp_configs: for bouquet_entry in bouquets_list: if bouquet_entry[0] == providers_tmp_configs[provider].getCustomFilename(): bouquet_default = bouquet_entry[0] break self.providers_custommain[provider] = ConfigSelection(default = bouquet_default, choices = bouquets_list) makemain_list.append(("no", _("no"))) self.providers_makemain[provider] = ConfigSelection(default = makemain_default, choices = makemain_list) elif custom_bouquets_exists: makemain_default = "no" if provider not in providers_tmp_configs: makemain_default = "yes" if provider in providers_tmp_configs and providers_tmp_configs[provider].isMakeNormalMain(): makemain_default = "yes" self.providers_makemain[provider] = ConfigSelection(default = makemain_default, choices = [("yes", _("yes")), ("no", _("no"))]) arealist = [] bouquets = self.providers[provider]["bouquets"] for bouquet in bouquets.keys(): arealist.append((bouquet, self.providers[provider]["bouquets"][bouquet]["name"])) arealist.sort() if len(self.providers[provider]["bouquets"]) > 0: # provider has area list default_area = None if provider in providers_tmp_configs: default_area = providers_tmp_configs[provider].getArea() self.providers_area[provider] = ConfigSelection(default = default_area, choices = arealist) # FTA only FTA_only = config.autobouquetsmaker.FTA_only.value.split("|") FTA = self.providers[provider]["protocol"] != "fastscan" and config.autobouquetsmaker.level.value == "expert" and provider in FTA_only self.providers_FTA_only[provider] = ConfigYesNo(default = FTA) self.createSetup() self["pleasewait"].hide() self["actions"].setEnabled(True)
def createConfig(self, frontendData): 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_8psk": eDVBFrontendParametersSatellite.FEC_Auto, "fec_s2_qpsk": eDVBFrontendParametersSatellite.FEC_Auto, "modulation": eDVBFrontendParametersSatellite.Modulation_QPSK } if frontendData is not None: ttype = frontendData.get("tuner_type", "UNKNOWN") if ttype == "DVB-S": 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) defaultSat["modulation"] = frontendData.get( "modulation", eDVBFrontendParametersSatellite.Modulation_QPSK) if defaultSat[ "system"] == eDVBFrontendParametersSatellite.System_DVB_S2: if defaultSat[ "modulation"] == eDVBFrontendParametersSatellite.Modulation_QPSK: defaultSat["fec_s2_qpsk"] = frontendData.get( "fec_inner", eDVBFrontendParametersSatellite.FEC_Auto) else: defaultSat["fec_s2_8psk"] = 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"] = frontendData.get( "fec_inner", eDVBFrontendParametersSatellite.FEC_Auto) defaultSat["orbpos"] = frontendData.get("orbital_position", 0) self.scan_sat = ConfigSubsection() 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) # self.scan_skipEmpty = ConfigYesNo(default = True) # self.scan_otherSDT = ConfigYesNo(default = False) nim_list = [] # collect all nims which are *not* set to "nothing" for n in nimmanager.nim_slots: if not n.isCompatible("DVB-S"): continue if not self.legacy: config = n.config.dvbs else: config = n.config config_mode = config.configMode.value if config_mode == "nothing": continue if config_mode == "advanced" and len( nimmanager.getSatListForNim(n.slot)) < 1: continue if config_mode in ("loopthrough", "satposdepends"): root_id = nimmanager.sec.getRoot(n.slot_id, int(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) self.scan_sat.bs_system = ConfigSelection( default=eDVBFrontendParametersSatellite.System_DVB_S2, choices=[(eDVBFrontendParametersSatellite.System_DVB_S2, _("DVB-S + DVB-S2")), (eDVBFrontendParametersSatellite.System_DVB_S, _("DVB-S only"))]) self.scan_sat.bs_accuracy = ConfigSelection(default=2, choices=[ (1, "1"), (2, "2"), (3, "3"), (4, "4"), (5, "5") ]) self.scan_sat.bs_horizontal = ConfigYesNo(default=True) self.scan_sat.bs_vertical = ConfigYesNo(default=True) self.scan_scansat = {} for sat in nimmanager.satList: #print sat[1] self.scan_scansat[sat[0]] = ConfigYesNo(default=False) sec = secClass.getInstance() self.nim_sat_frequency_range = [] self.nim_sat_band_cutoff_frequency = [] self.scan_satselection = [] for slot in nimmanager.nim_slots: slot_id = slot.slot self.nim_sat_frequency_range.append if slot.isCompatible("DVB-S"): satlist_for_slot = self.satList[slot_id] self.scan_satselection.append( getConfigSatlist(defaultSat["orbpos"], satlist_for_slot)) sat_freq_range = {} sat_band_cutoff = {} for sat in satlist_for_slot: orbpos = sat[0] sat_freq_range[orbpos] = sec.getFrequencyRangeList( slot_id, orbpos) sat_band_cutoff[orbpos] = sec.getBandCutOffFrequency( slot_id, orbpos) self.nim_sat_frequency_range.append(sat_freq_range) self.nim_sat_band_cutoff_frequency.append(sat_band_cutoff) else: self.nim_sat_frequency_range.append(None) self.nim_sat_band_cutoff_frequency.append(None) self.scan_satselection.append(None) return True
def createConfig(self, frontendData): 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_8psk": eDVBFrontendParametersSatellite.FEC_Auto, "fec_s2_qpsk": eDVBFrontendParametersSatellite.FEC_Auto, "modulation": eDVBFrontendParametersSatellite.Modulation_QPSK } if frontendData is not None: ttype = frontendData.get("tuner_type", "UNKNOWN") if ttype == "DVB-S": 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) defaultSat["modulation"] = frontendData.get("modulation", eDVBFrontendParametersSatellite.Modulation_QPSK) if defaultSat["system"] == eDVBFrontendParametersSatellite.System_DVB_S2: if defaultSat["modulation"] == eDVBFrontendParametersSatellite.Modulation_QPSK: defaultSat["fec_s2_qpsk"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto) else: defaultSat["fec_s2_8psk"] = 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"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto) defaultSat["orbpos"] = frontendData.get("orbital_position", 0) self.scan_sat = ConfigSubsection() 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) # self.scan_skipEmpty = ConfigYesNo(default = True) # self.scan_otherSDT = ConfigYesNo(default = False) nim_list = [] # collect all nims which are *not* set to "nothing" for n in nimmanager.nim_slots: if not n.isCompatible("DVB-S"): continue if not self.legacy: nimconfig = n.config.dvbs else: nimconfig = n.config config_mode = nimconfig.configMode.value if config_mode == "nothing": continue if config_mode == "advanced" and len(nimmanager.getSatListForNim(n.slot)) < 1: continue if config_mode in ("loopthrough", "satposdepends"): root_id = nimmanager.sec.getRoot(n.slot_id, int(nimconfig.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) self.scan_sat.bs_system = ConfigSelection(default = eDVBFrontendParametersSatellite.System_DVB_S2, choices = [ (eDVBFrontendParametersSatellite.System_DVB_S2, _("DVB-S + DVB-S2")), (eDVBFrontendParametersSatellite.System_DVB_S, _("DVB-S only"))]) self.scan_sat.bs_accuracy = ConfigSelection(default = 2, choices = [ (1, "1"), (2, "2"), (3, "3"), (4, "4"), (5, "5")]) self.scan_sat.bs_horizontal = ConfigYesNo(default = True) self.scan_sat.bs_vertical = ConfigYesNo(default = True) self.scan_scansat = {} for sat in nimmanager.satList: #print sat[1] self.scan_scansat[sat[0]] = ConfigYesNo(default = False) sec = secClass.getInstance() self.nim_sat_frequency_range = [] self.nim_sat_band_cutoff_frequency = [] self.scan_satselection = [] for slot in nimmanager.nim_slots: slot_id = slot.slot self.nim_sat_frequency_range.append if slot.isCompatible("DVB-S"): satlist_for_slot = self.satList[slot_id] self.scan_satselection.append(getConfigSatlist(defaultSat["orbpos"], satlist_for_slot)) sat_freq_range = {} sat_band_cutoff = {} for sat in satlist_for_slot: orbpos = sat[0] sat_freq_range[orbpos] = sec.getFrequencyRangeList(slot_id, orbpos) sat_band_cutoff[orbpos] = sec.getBandCutOffFrequency(slot_id, orbpos) self.nim_sat_frequency_range.append(sat_freq_range) self.nim_sat_band_cutoff_frequency.append(sat_band_cutoff) else: self.nim_sat_frequency_range.append(None) self.nim_sat_band_cutoff_frequency.append(None) self.scan_satselection.append(None) return True
class Satfinder(ScanSetup, ServiceScan): def __init__(self, session): self.initcomplete = False service = session and session.nav.getCurrentService() feinfo = service and service.frontendInfo() self.frontendData = feinfo and feinfo.getAll(True) del feinfo del service self.preDefTransponders = None self.TerrestrialTransponders = None self.CableTransponders = None self.typeOfTuningEntry = None self.systemEntry = None self.systemEntryATSC = None self.satfinderTunerEntry = None self.satEntry = None self.typeOfInputEntry = None self.frequencyEntry = None self.polarizationEntry = None self.symbolrateEntry = None self.inversionEntry = None self.rolloffEntry = None self.pilotEntry = None self.modulationEntry = None self.fecEntry = None self.transponder = None self.DVB_TypeEntry = None self.systemEntryTerr = None ScanSetup.__init__(self, session) self.setTitle(_("Signal Finder")) self["introduction"].setText(_("Press OK to scan")) self["Frontend"] = FrontendStatus( frontend_source=lambda: self.frontend, update_interval=100) self["actions"] = ActionMap( ["SetupActions", "ColorActions"], { "save": self.keyGoScan, "ok": self.keyGoScan, "cancel": self.keyCancel, }, -3) self.initcomplete = True self.session.postScanService = self.session.nav.getCurrentlyPlayingServiceOrGroup( ) self.onClose.append(self.__onClose) self.onShow.append(self.prepareFrontend) 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 return False def prepareFrontend(self): self.frontend = None if not self.openFrontend(): self.session.nav.stopService() if not self.openFrontend(): if self.session.pipshown: from Screens.InfoBar import InfoBar InfoBar.instance and hasattr( InfoBar.instance, "showPiP") and InfoBar.instance.showPiP() if not self.openFrontend(): self.frontend = None # in normal case this should not happen self.tuner = Tuner(self.frontend) if nimmanager.nim_slots[int( self.satfinder_scan_nims.value)].isCompatible("DVB-S"): self.updatePreDefTransponders() self.createSetup() self.retune(None) def __onClose(self): self.session.nav.playService(self.session.postScanService) def newConfig(self): cur = self["config"].getCurrent() if cur in (self.typeOfTuningEntry, self.systemEntry, self.typeOfInputEntry, self.systemEntryATSC, self.DVB_TypeEntry, self.systemEntryTerr): self.createSetup() elif cur == self.satfinderTunerEntry: self.preDefTransponders = None self.TerrestrialTransponders = None self.CableTransponders = None self.feid = int(self.satfinder_scan_nims.value) self.createSetup() self.prepareFrontend() if self.frontend is None: msg = _("Tuner not available.") if self.session.nav.RecordTimer.isRecording(): msg += _("\nRecording in progress.") self.session.open(MessageBox, msg, MessageBox.TYPE_ERROR) else: if cur == self.satEntry: self.preDefTransponders = None self.createSetup() if cur not in (self.systemEntry, self.satfinderTunerEntry, self.frequencyEntry, self.polarizationEntry, self.symbolrateEntry, self.inversionEntry, self.rolloffEntry, self.fecEntry, self.pilotEntry, self.modulationEntry, self.systemEntryATSC): self.retune(None) def createSetup(self): self.list = [] self.satfinderTunerEntry = getConfigListEntry(_("Tuner"), self.satfinder_scan_nims) self.list.append(self.satfinderTunerEntry) if nimmanager.nim_slots[int( self.satfinder_scan_nims.value)].isCompatible("DVB-S"): self.tuning_sat = self.scan_satselection[self.getSelectedSatIndex( self.feid)] if self.tuning_sat.value: self.satEntry = getConfigListEntry(_('Satellite'), self.tuning_sat) self.list.append(self.satEntry) self.typeOfTuningEntry = getConfigListEntry( _('Tune'), self.tuning_type) if len( nimmanager.getTransponders(int(self.tuning_sat.value)) ) < 1: # Only offer 'predefined transponder' if some transponders exist self.tuning_type.value = "single_transponder" else: self.list.append(self.typeOfTuningEntry) nim = nimmanager.nim_slots[self.feid] if self.tuning_type.value == "single_transponder": if nim.isCompatible("DVB-S2"): self.systemEntry = getConfigListEntry( _('System'), self.scan_sat.system) self.list.append(self.systemEntry) else: # downgrade to dvb-s, in case a -s2 config was active self.scan_sat.system.value = eDVBFrontendParametersSatellite.System_DVB_S self.frequencyEntry = getConfigListEntry( _('Frequency'), self.scan_sat.frequency) self.list.append(self.frequencyEntry) self.polarizationEntry = getConfigListEntry( _('Polarization'), self.scan_sat.polarization) self.list.append(self.polarizationEntry) self.symbolrateEntry = (getConfigListEntry( _('Symbol rate'), self.scan_sat.symbolrate)) self.list.append(self.symbolrateEntry) self.inversionEntry = getConfigListEntry( _('Inversion'), self.scan_sat.inversion) self.list.append(self.inversionEntry) if self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S: self.fecEntry = getConfigListEntry( _("FEC"), self.scan_sat.fec) self.list.append(self.fecEntry) elif self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S2: self.fecEntry = getConfigListEntry( _("FEC"), self.scan_sat.fec_s2) self.list.append(self.fecEntry) self.modulationEntry = getConfigListEntry( _('Modulation'), self.scan_sat.modulation) self.list.append(self.modulationEntry) self.rolloffEntry = getConfigListEntry( _('Roll-off'), self.scan_sat.rolloff) self.list.append(self.rolloffEntry) self.pilotEntry = getConfigListEntry( _('Pilot'), self.scan_sat.pilot) self.list.append(self.pilotEntry) if nim.isMultistream(): self.list.append( getConfigListEntry(_('Input Stream ID'), self.scan_sat.is_id)) self.list.append( getConfigListEntry(_('PLS Mode'), self.scan_sat.pls_mode)) self.list.append( getConfigListEntry(_('PLS Code'), self.scan_sat.pls_code)) elif self.tuning_type.value == "predefined_transponder": if self.preDefTransponders is None: self.updatePreDefTransponders() self.list.append( getConfigListEntry(_("Transponder"), self.preDefTransponders)) elif nimmanager.nim_slots[int( self.satfinder_scan_nims.value)].isCompatible("DVB-C"): self.typeOfTuningEntry = getConfigListEntry( _('Tune'), self.tuning_type) if config.Nims[self.feid].cable.scan_type.value != "provider" or len( nimmanager.getTranspondersCable( int(self.satfinder_scan_nims.value)) ) < 1: # only show 'predefined transponder' if in provider mode and transponders exist self.tuning_type.value = "single_transponder" else: self.list.append(self.typeOfTuningEntry) if self.tuning_type.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(_("Modulation"), self.scan_cab.modulation)) self.list.append( getConfigListEntry(_("FEC"), self.scan_cab.fec)) elif self.tuning_type.value == "predefined_transponder": self.scan_nims.value = self.satfinder_scan_nims.value if self.CableTransponders is None: self.predefinedCabTranspondersList() self.list.append( getConfigListEntry(_('Transponder'), self.CableTransponders)) elif nimmanager.nim_slots[int( self.satfinder_scan_nims.value)].isCompatible("DVB-T"): self.typeOfTuningEntry = getConfigListEntry( _('Tune'), self.tuning_type) region = nimmanager.getTerrestrialDescription( int(self.satfinder_scan_nims.value)) if len( nimmanager.getTranspondersTerrestrial(region) ) < 1: # Only offer 'predefined transponder' if some transponders exist self.tuning_type.value = "single_transponder" else: self.list.append(self.typeOfTuningEntry) if self.tuning_type.value == "single_transponder": if nimmanager.nim_slots[int( self.satfinder_scan_nims.value)].isCompatible( "DVB-T2"): self.systemEntryTerr = getConfigListEntry( _('System'), self.scan_ter.system) self.list.append(self.systemEntryTerr) else: self.scan_ter.system.value = eDVBFrontendParametersTerrestrial.System_DVB_T self.typeOfInputEntry = getConfigListEntry( _("Use frequency or channel"), self.scan_input_as) if self.ter_channel_input: self.list.append(self.typeOfInputEntry) else: self.scan_input_as.value = self.scan_input_as.choices[0] if self.ter_channel_input and self.scan_input_as.value == "channel": channel = getChannelNumber( self.scan_ter.frequency.floatint * 1000, self.ter_tnumber) if channel: self.scan_ter.channel.removeNotifier( self.retuneTriggeredByConfigElement) self.scan_ter.channel.value = int( channel.replace("+", "").replace("-", "")) self.list.append( getConfigListEntry(_("Channel"), self.scan_ter.channel)) else: prev_val = self.scan_ter.frequency.floatint self.scan_ter.frequency.floatint = channel2frequency( self.scan_ter.channel.value, self.ter_tnumber) / 1000 if self.scan_ter.frequency.floatint == 474000: self.scan_ter.frequency.floatint = prev_val 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)) if self.scan_ter.system.value == eDVBFrontendParametersTerrestrial.System_DVB_T2: self.list.append( getConfigListEntry(_('PLP ID'), self.scan_ter.plp_id)) elif self.tuning_type.value == "predefined_transponder": self.scan_nims.value = self.satfinder_scan_nims.value if self.TerrestrialTransponders is None: self.predefinedTerrTranspondersList() self.list.append( getConfigListEntry(_('Transponder'), self.TerrestrialTransponders)) elif nimmanager.nim_slots[int( self.satfinder_scan_nims.value)].isCompatible("ATSC"): self.typeOfTuningEntry = getConfigListEntry( _('Tune'), self.tuning_type) if len( nimmanager.getTranspondersATSC( int(self.satfinder_scan_nims.value)) ) < 1: # only show 'predefined transponder' if transponders exist self.tuning_type.value = "single_transponder" else: self.list.append(self.typeOfTuningEntry) if self.tuning_type.value == "single_transponder": self.systemEntryATSC = getConfigListEntry( _("System"), self.scan_ats.system) self.list.append(self.systemEntryATSC) self.list.append( getConfigListEntry(_("Frequency"), self.scan_ats.frequency)) self.list.append( getConfigListEntry(_("Inversion"), self.scan_ats.inversion)) self.list.append( getConfigListEntry(_("Modulation"), self.scan_ats.modulation)) elif self.tuning_type.value == "predefined_transponder": #FIXME add region self.scan_nims.value = self.satfinder_scan_nims.value self.predefinedATSCTranspondersList() self.list.append( getConfigListEntry(_('Transponder'), self.ATSCTransponders)) self["config"].list = self.list self["config"].l.setList(self.list) def createConfig(self, foo): self.tuning_type = ConfigSelection( default="predefined_transponder", choices=[("single_transponder", _("User defined transponder")), ("predefined_transponder", _("Predefined transponder"))]) self.orbital_position = 192 if self.frontendData and 'orbital_position' in self.frontendData: self.orbital_position = self.frontendData['orbital_position'] ScanSetup.createConfig(self, self.frontendData) for x in (self.scan_sat.frequency, self.scan_sat.inversion, self.scan_sat.symbolrate, self.scan_sat.polarization, self.scan_sat.fec, self.scan_sat.pilot, self.scan_sat.fec_s2, self.scan_sat.fec, self.scan_sat.modulation, self.scan_sat.rolloff, self.scan_sat.system, self.scan_sat.is_id, self.scan_sat.pls_mode, self.scan_sat.pls_code, self.scan_ter.channel, self.scan_ter.frequency, self.scan_ter.inversion, self.scan_ter.bandwidth, self.scan_ter.fechigh, self.scan_ter.feclow, self.scan_ter.modulation, self.scan_ter.transmission, self.scan_ter.guard, self.scan_ter.hierarchy, self.scan_ter.plp_id, self.scan_cab.frequency, self.scan_cab.inversion, self.scan_cab.symbolrate, self.scan_cab.modulation, self.scan_cab.fec, self.scan_ats.frequency, self.scan_ats.modulation, self.scan_ats.inversion, self.scan_ats.system): x.addNotifier(self.retune, initial_call=False) satfinder_nim_list = [] for n in nimmanager.nim_slots: if not any( [n.isCompatible(x) for x in "DVB-S", "DVB-T", "DVB-C", "ATSC"]): continue if n.config_mode in ("loopthrough_internal", "loopthrough_external", "satposdepends", "nothing"): continue if n.isCompatible("DVB-S") and n.config_mode == "advanced" and len( nimmanager.getSatListForNim(n.slot)) < 1: continue satfinder_nim_list.append( (str(n.slot), n.friendly_full_description)) self.satfinder_scan_nims = ConfigSelection(choices=satfinder_nim_list) if self.frontendData is not None and len( satfinder_nim_list ) > 0: # open the plugin with the currently active NIM as default self.satfinder_scan_nims.setValue( str( self.frontendData.get("tuner_number", satfinder_nim_list[0][0]))) self.feid = int(self.satfinder_scan_nims.value) self.satList = [] self.scan_satselection = [] for slot in nimmanager.nim_slots: if slot.isCompatible("DVB-S"): self.satList.append(nimmanager.getSatListForNim(slot.slot)) self.scan_satselection.append( getConfigSatlist(self.orbital_position, self.satList[slot.slot])) else: self.satList.append(None) if self.frontendData: ttype = self.frontendData.get("tuner_type", "UNKNOWN") if ttype == "DVB-S" and self.predefinedTranspondersList( self.getSelectedSatIndex(self.feid)) is None and len( nimmanager.getTransponders( self.getSelectedSatIndex(self.feid))) > 0: self.tuning_type.value = "single_transponder" elif ttype == "DVB-T" and self.predefinedTerrTranspondersList( ) is None and len( nimmanager.getTranspondersTerrestrial( nimmanager.getTerrestrialDescription(self.feid))) > 0: self.tuning_type.value = "single_transponder" elif ttype == "DVB-C" and self.predefinedCabTranspondersList( ) is None and len(nimmanager.getTranspondersCable(self.feid)) > 0: self.tuning_type.value = "single_transponder" elif ttype == "ATSC" and self.predefinedATSCTranspondersList( ) is None and len(nimmanager.getTranspondersATSC(self.feid)) > 0: self.tuning_type.value = "single_transponder"
def createSetup(self): self.list = [] self.multiscanlist = [] index_to_scan = int(self.scan_nims.value) print "ID: ", index_to_scan self.tunerEntry = getConfigListEntry(_("Tuner"), self.scan_nims) self.list.append(self.tunerEntry) if self.scan_nims == [ ]: return self.typeOfScanEntry = None self.systemEntry = None self.modulationEntry = None nim = nimmanager.nim_slots[index_to_scan] if nim.isCompatible("DVB-S"): self.typeOfScanEntry = getConfigListEntry(_("Type of scan"), self.scan_type) self.list.append(self.typeOfScanEntry) elif nim.isCompatible("DVB-C"): self.typeOfScanEntry = getConfigListEntry(_("Type of scan"), self.scan_typecable) self.list.append(self.typeOfScanEntry) elif nim.isCompatible("DVB-T"): 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() if nim.isCompatible("DVB-S2"): self.systemEntry = getConfigListEntry(_('System'), self.scan_sat.system) self.list.append(self.systemEntry) else: # downgrade to dvb-s, in case a -s2 config was active 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 == eDVBFrontendParametersSatellite.System_DVB_S: self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec)) 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)) 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.scan_networkScan.value = True elif self.scan_type.value.find("multisat") != -1: tlist = [] SatList = nimmanager.getSatListForNim(index_to_scan) for x in SatList: if self.Satexists(tlist, x[0]) == 0: tlist.append(x[0]) 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)) 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(_("Modulation"), self.scan_cab.modulation)) self.list.append(getConfigListEntry(_("FEC"), self.scan_cab.fec)) if config.Nims[index_to_scan].cable.scan_networkid.value: self.networkid = config.Nims[index_to_scan].cable.scan_networkid.value self.scan_networkScan.value = True 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)) 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)
def doTune(self): from Screens.Standby import inStandby if self.providers[self.currentAction]["streamtype"] == "dvbs": transponder = self.providers[self.currentAction]["transponder"] else: bouquet_key = None providers_tmp = config.autobouquetsmaker.providers.value.split("|") for provider_tmp in providers_tmp: provider_config = ProviderConfig(provider_tmp) provider_key = provider_config.getProvider() if self.currentAction != provider_key: continue bouquet_key = provider_config.getArea() if not bouquet_key: print >> log, "[AutoBouquetsMaker] No area found" self.showError(_("No area found")) return transponder = self.providers[self.currentAction]["bouquets"][bouquet_key] nimList = [] for nim in nimmanager.nim_slots: if (nim.config_mode not in ("loopthrough", "satposdepends", "nothing")) and ( (self.providers[self.currentAction]["streamtype"] == "dvbs" and nim.isCompatible("DVB-S")) or (self.providers[self.currentAction]["streamtype"] == "dvbc" and nim.isCompatible("DVB-C")) or (self.providers[self.currentAction]["streamtype"] == "dvbt" and nim.isCompatible("DVB-T")) ): nimList.append(nim.slot) if len(nimList) == 0: print >> log, "[AutoBouquetsMaker] No NIMs found" self.showError(_("No NIMs found")) return resmanager = eDVBResourceManager.getInstance() if not resmanager: print >> log, "[AutoBouquetsMaker] Cannot retrieve Resource Manager instance" self.showError(_("Cannot retrieve Resource Manager instance")) return if self.providers[self.currentAction]["streamtype"] == "dvbs": print >> log, "[AutoBouquetsMaker] Search NIM for orbital position %d" % transponder["orbital_position"] else: print >> log, "[AutoBouquetsMaker] Search NIM" # stop pip if running if self.session.pipshown: self.session.pipshown = False del self.session.pip print >> log, "[AutoBouquetsMaker] Stopping PIP." # stop currently playing service if it is using a tuner in ("loopthrough", "satposdepends") currentlyPlayingNIM = None currentService = self.session and self.session.nav.getCurrentService() frontendInfo = currentService and currentService.frontendInfo() frontendData = frontendInfo and frontendInfo.getAll(True) if frontendData is not None: currentlyPlayingNIM = frontendData.get("tuner_number", None) if self.providers[self.currentAction]["streamtype"] == "dvbs" and currentlyPlayingNIM is not None: nimConfigMode = nimmanager.nim_slots[currentlyPlayingNIM].config_mode if nimConfigMode in ("loopthrough", "satposdepends"): self.postScanService = self.session.nav.getCurrentlyPlayingServiceReference() self.session.nav.stopService() currentlyPlayingNIM = None print >> log, "[AutoBouquetsMaker] The active service was using a %s tuner, so had to be stopped (slot id %s)." % ( nimConfigMode, currentlyPlayingNIM, ) del frontendInfo del currentService current_slotid = -1 if self.rawchannel: del (self.rawchannel) self.frontend = None self.rawchannel = None nimList.reverse() # start from the last for slotid in nimList: if self.providers[self.currentAction]["streamtype"] == "dvbs": sats = nimmanager.getSatListForNim(slotid) for sat in sats: if sat[0] == transponder["orbital_position"]: if current_slotid == -1: # mark the first valid slotid in case of no other one is free current_slotid = slotid self.rawchannel = resmanager.allocateRawChannel(slotid) if self.rawchannel: print >> log, "[AutoBouquetsMaker] Nim found on slot id %d with sat %s" % (slotid, sat[1]) current_slotid = slotid break else: if current_slotid == -1: # mark the first valid slotid in case of no other one is free current_slotid = slotid self.rawchannel = resmanager.allocateRawChannel(slotid) if self.rawchannel: print >> log, "[AutoBouquetsMaker] Nim found on slot id %d" % (slotid) current_slotid = slotid break if self.rawchannel: break if current_slotid == -1: print >> log, "[AutoBouquetsMaker] No valid NIM found" self.showError(_("No valid NIM found")) return if not self.rawchannel: # if we are here the only possible option is to close the active service if currentlyPlayingNIM in nimList: slotid = currentlyPlayingNIM if self.providers[self.currentAction]["streamtype"] == "dvbs": sats = nimmanager.getSatListForNim(currentlyPlayingNIM) for sat in sats: if sat[0] == transponder["orbital_position"]: print >> log, "[AutoBouquetsMaker] Nim found on slot id %d but it's busy. Stopping active service" % currentlyPlayingNIM self.postScanService = self.session.nav.getCurrentlyPlayingServiceReference() self.session.nav.stopService() self.rawchannel = resmanager.allocateRawChannel(slotid) break else: print >> log, "[AutoBouquetsMaker] Nim found on slot id %d but it's busy. Stopping active service" % currentlyPlayingNIM self.postScanService = self.session.nav.getCurrentlyPlayingServiceReference() self.session.nav.stopService() self.rawchannel = resmanager.allocateRawChannel(slotid) if not self.rawchannel: if self.session.nav.RecordTimer.isRecording(): print >> log, "[AutoBouquetsMaker] Cannot free NIM because a record is in progress" self.showError(_("Cannot free NIM because a recording is in progress")) return else: print >> log, "[AutoBouquetsMaker] Cannot get the NIM" self.showError(_("Cannot get the NIM")) return # set extended timeout for rotors if self.providers[self.currentAction]["streamtype"] == "dvbs" and self.isRotorSat( slotid, transponder["orbital_position"] ): self.LOCK_TIMEOUT = self.LOCK_TIMEOUT_ROTOR print >> log, "[AutoBouquetsMaker] Motorised dish. Will wait up to %i seconds for tuner lock." % ( self.LOCK_TIMEOUT / 10 ) else: self.LOCK_TIMEOUT = self.LOCK_TIMEOUT_FIXED print >> log, "[AutoBouquetsMaker] Fixed dish. Will wait up to %i seconds for tuner lock." % ( self.LOCK_TIMEOUT / 10 ) self.frontend = self.rawchannel.getFrontend() if not self.frontend: print >> log, "[AutoBouquetsMaker] Cannot get frontend" self.showError(_("Cannot get frontend")) return demuxer_id = self.rawchannel.reserveDemux() if demuxer_id < 0: print >> log, "[AutoBouquetsMaker] Cannot allocate the demuxer" self.showError(_("Cannot allocate the demuxer")) return if self.providers[self.currentAction]["streamtype"] == "dvbs": params = eDVBFrontendParametersSatellite() params.frequency = transponder["frequency"] params.symbol_rate = transponder["symbol_rate"] params.polarisation = transponder["polarization"] params.fec = transponder["fec_inner"] params.inversion = transponder["inversion"] params.orbital_position = transponder["orbital_position"] params.system = transponder["system"] params.modulation = transponder["modulation"] params.rolloff = transponder["roll_off"] params.pilot = transponder["pilot"] params_fe = eDVBFrontendParameters() params_fe.setDVBS(params, False) elif self.providers[self.currentAction]["streamtype"] == "dvbt": params = eDVBFrontendParametersTerrestrial() params.frequency = transponder["frequency"] params.bandwidth = transponder["bandwidth"] params.code_rate_hp = transponder["code_rate_hp"] params.code_rate_lp = transponder["code_rate_lp"] params.inversion = transponder["inversion"] params.system = transponder["system"] params.modulation = transponder["modulation"] params.transmission_mode = transponder["transmission_mode"] params.guard_interval = transponder["guard_interval"] params.hierarchy = transponder["hierarchy"] params_fe = eDVBFrontendParameters() params_fe.setDVBT(params) elif self.providers[self.currentAction]["streamtype"] == "dvbc": params = eDVBFrontendParametersCable() params.frequency = transponder["frequency"] params.symbol_rate = transponder["symbol_rate"] params.fec_inner = transponder["fec_inner"] params.inversion = transponder["inversion"] params.modulation = transponder["modulation"] params_fe = eDVBFrontendParameters() params_fe.setDVBC(params) self.rawchannel.requestTsidOnid() self.frontend.tune(params_fe) self.manager.setAdapter(0) # FIX: use the correct device self.manager.setDemuxer(demuxer_id) self.manager.setFrontend(current_slotid) self.lockcounter = 0 self.locktimer = eTimer() self.locktimer.callback.append(self.checkTunerLock) self.locktimer.start(100, 1)
def keyGo(self): if self.scan_nims.value == "": return tlist = [] flags = None startScan = True removeAll = True index_to_scan = int(self.scan_nims.value) if self.scan_nims == [ ]: self.session.open(MessageBox, _("No tuner is enabled!\nPlease setup your tuner settings before you start a service scan."), MessageBox.TYPE_ERROR) return nim = nimmanager.nim_slots[index_to_scan] print "nim", nim.slot if nim.isCompatible("DVB-S"): print "is compatible with DVB-S" if self.scan_type.value == "single_transponder": # these lists are generated for each tuner, so this has work. assert len(self.satList) > index_to_scan assert len(self.scan_satselection) > index_to_scan nimsats = self.satList[index_to_scan] selsatidx = self.scan_satselection[index_to_scan].index # 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 == 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.value, fec, self.scan_sat.inversion.value, orbpos, 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.find("multisat") != -1: SatList = nimmanager.getSatListForNim(index_to_scan) for x in self.multiscanlist: if x[1].value: print " " + str(x[0]) getInitialTransponderList(tlist, x[0]) elif nim.isCompatible("DVB-C"): if self.scan_typecable.value == "single_transponder": self.addCabTransponder(tlist, self.scan_cab.frequency.value, self.scan_cab.symbolrate.value, 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 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.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) removeAll = False elif self.scan_typeterrestrial.value == "complete": getInitialTerrestrialTransponderList(tlist, nimmanager.getTerrestrialDescription(index_to_scan)) 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: self.startScan(tlist, flags, index_to_scan, self.networkid) else: self.flags = flags self.feid = index_to_scan self.tlist = [] self.startCableTransponderSearch(self.feid)
def createConfig(self): self.feinfo = None frontendData = None 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 } self.service = self.session.nav.getCurrentService() if self.service is not None: self.feinfo = self.service.frontendInfo() frontendData = self.feinfo and self.feinfo.getAll(True) if frontendData is not None: ttype = frontendData.get("tuner_type", "UNKNOWN") if ttype == "DVB-S": 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"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto) defaultSat["modulation"] = frontendData.get("modulation", eDVBFrontendParametersSatellite.Modulation_QPSK) defaultSat["orbpos"] = frontendData.get("orbital_position", 0) del self.feinfo del self.service del frontendData self.scan_sat = ConfigSubsection() self.scan_networkScan = ConfigYesNo(default = False) #ConfigYesNo(default = True) self.blindscan_start_frequency = ConfigInteger(default = 10700, limits = (1, 99999)) self.blindscan_stop_frequency = ConfigInteger(default = 12750, limits = (1, 99999)) self.blindscan_start_symbol = ConfigInteger(default = 2, limits = (1, 99)) self.blindscan_stop_symbol = ConfigInteger(default = 45, limits = (1, 99)) self.scan_clearallservices = ConfigYesNo(default = False) self.scan_onlyfree = ConfigYesNo(default = False) self.dont_scan_known_tps = ConfigYesNo(default = False) self.filter_off_adjacent_satellites = ConfigSelection(default = 0, choices = [ (0, _("no")), (1, _("up to 1 degree")), (2, _("up to 2 degrees")), (3, _("up to 3 degrees"))]) self.search_type = ConfigSelection(default = 0, choices = [ (0, _("scan for channels")), (1, _("save to XML file"))]) # collect all nims which are *not* set to "nothing" nim_list = [] for n in nimmanager.nim_slots: 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 if n.isCompatible("DVB-S"): nim_list.append((str(n.slot), n.friendly_full_description)) self.scan_nims = ConfigSelection(choices = nim_list) # sat self.scan_sat.frequency = ConfigInteger(default = defaultSat["frequency"], limits = (1, 99999)) self.scan_sat.polarization = ConfigSelection(default = eDVBFrontendParametersSatellite.Polarisation_CircularRight + 1, choices = [ (eDVBFrontendParametersSatellite.Polarisation_CircularRight + 1, _("vertical and horizontal")), (eDVBFrontendParametersSatellite.Polarisation_Vertical, _("vertical")), (eDVBFrontendParametersSatellite.Polarisation_Horizontal, _("horizontal")), (eDVBFrontendParametersSatellite.Polarisation_CircularRight + 2, _("circular right and circular left")), (eDVBFrontendParametersSatellite.Polarisation_CircularRight, _("circular right")), (eDVBFrontendParametersSatellite.Polarisation_CircularLeft, _("circular left"))]) self.scan_scansat = {} for sat in nimmanager.satList: self.scan_scansat[sat[0]] = ConfigYesNo(default = False) self.scan_satselection = [] for slot in nimmanager.nim_slots: if slot.isCompatible("DVB-S"): self.scan_satselection.append(getConfigSatlist(defaultSat["orbpos"], self.satList[slot.slot])) return True
def prepare(self): self.activityTimer.stop() self.providers = Manager().getProviders() self.providers_configs = {} self.providers_area = {} self.providers_swapchannels = {} self.providers_makemain = {} self.providers_custommain = {} self.providers_makesections = {} self.providers_makehd = {} self.providers_makefta = {} self.providers_makeftahd = {} self.providers_order = [] self.orbital_supported = [] # get supported orbital positions dvbs_nims = nimmanager.getNimListOfType("DVB-S") for nim in dvbs_nims: sats = nimmanager.getSatListForNim(nim) for sat in sats: if sat[0] not in self.orbital_supported: self.orbital_supported.append(sat[0]) self.dvbc_nims = nimmanager.getNimListOfType("DVB-C") self.dvbt_nims = nimmanager.getNimListOfType("DVB-T") # read providers configurations providers_tmp_configs = {} providers_tmp = config.autobouquetsmaker.providers.value.split("|") for provider_tmp in providers_tmp: provider_config = ProviderConfig(provider_tmp) if not provider_config.isValid(): continue if provider_config.getProvider() not in self.providers: continue if self.providers[provider_config.getProvider()]["streamtype"] == 'dvbs' and self.providers[provider_config.getProvider()]["transponder"]["orbital_position"] not in self.orbital_supported: continue if self.providers[provider_config.getProvider()]["streamtype"] == 'dvbc' and len(self.dvbc_nims) <= 0: continue if self.providers[provider_config.getProvider()]["streamtype"] == 'dvbt' and len(self.dvbt_nims) <= 0: continue self.providers_order.append(provider_config.getProvider()) providers_tmp_configs[provider_config.getProvider()] = provider_config # get current bouquets list (for custom main) bouquets = Manager().getBouquetsList() bouquets_list = [] if bouquets["tv"] is not None: for bouquet in bouquets["tv"]: if bouquet["filename"][:12] == "autobouquet.": continue bouquets_list.append((bouquet["filename"], bouquet["name"])) # build providers configurations for provider in self.providers.keys(): self.providers_configs[provider] = ConfigYesNo(default = (provider in providers_tmp_configs.keys())) self.providers_swapchannels[provider] = ConfigYesNo(default = (provider in providers_tmp_configs and providers_tmp_configs[provider].isSwapChannels())) custom_bouquets_exists = False self.providers_makemain[provider] = None self.providers_custommain[provider] = None self.providers_makesections[provider] = None self.providers_makehd[provider] = None self.providers_makefta[provider] = None self.providers_makeftahd[provider] = None if len(self.providers[provider]["sections"].keys()) > 1: # only if there's more then one section sections_default = True if provider in providers_tmp_configs: sections_default = providers_tmp_configs[provider].isMakeSections() self.providers_makesections[provider] = ConfigYesNo(default = sections_default) custom_bouquets_exists = True if self.providers[provider]["protocol"] != "fastscan": # fastscan doesn't have enough information to make HD and/or FTA bouquets hd_default = True fta_default = True ftahd_default = True if provider in providers_tmp_configs: hd_default = providers_tmp_configs[provider].isMakeHD() fta_default = providers_tmp_configs[provider].isMakeFTA() ftahd_default = providers_tmp_configs[provider].isMakeFTAHD() self.providers_makehd[provider] = ConfigYesNo(default = hd_default) self.providers_makefta[provider] = ConfigYesNo(default = fta_default) self.providers_makeftahd[provider] = ConfigYesNo(default = ftahd_default) custom_bouquets_exists = True if sorted(self.providers[provider]["sections"].keys())[0] > 1: makemain_default = "no" makemain_list = [] makemain_list.append(("yes", _("yes"))) if provider not in providers_tmp_configs: makemain_default = "yes" # enabled as default if provider in providers_tmp_configs and providers_tmp_configs[provider].isMakeNormalMain(): makemain_default = "yes" if self.providers[provider]["protocol"] != "fastscan" and self.providers[provider]["streamtype"] not in ("dvbt"): makemain_list.append(("hd", _("yes (only HD)"))) makemain_list.append(("ftahd", _("yes (only FTA HD)"))) if provider in providers_tmp_configs and providers_tmp_configs[provider].isMakeHDMain(): makemain_default = "hd" if provider in providers_tmp_configs and providers_tmp_configs[provider].isMakeFTAHDMain(): makemain_default = "ftahd" if len(bouquets_list) > 0: makemain_list.append(("custom", _("yes (custom)"))) if provider in providers_tmp_configs and providers_tmp_configs[provider].isMakeCustomMain(): makemain_default = "custom" bouquet_default = bouquets_list[0][0] if provider in providers_tmp_configs: for bouquet_entry in bouquets_list: if bouquet_entry[0] == providers_tmp_configs[provider].getCustomFilename(): bouquet_default = bouquet_entry[0] break self.providers_custommain[provider] = ConfigSelection(default = bouquet_default, choices = bouquets_list) makemain_list.append(("no", _("no"))) self.providers_makemain[provider] = ConfigSelection(default = makemain_default, choices = makemain_list) elif custom_bouquets_exists: makemain_default = "no" if provider not in providers_tmp_configs: makemain_default = "yes" if provider in providers_tmp_configs and providers_tmp_configs[provider].isMakeNormalMain(): makemain_default = "yes" self.providers_makemain[provider] = ConfigSelection(default = makemain_default, choices = [("yes", _("yes")), ("no", _("no"))]) arealist = [] bouquets = self.providers[provider]["bouquets"] for bouquet in bouquets.keys(): arealist.append((bouquet, self.providers[provider]["bouquets"][bouquet]["name"])) arealist.sort() if self.providers[provider]["protocol"] == "sky" or self.providers[provider]["protocol"] == "freesat" or self.providers[provider]["streamtype"] in ("dvbc", "dvbt"): default_area = None if provider in providers_tmp_configs: default_area = providers_tmp_configs[provider].getArea() self.providers_area[provider] = ConfigSelection(default = default_area, choices = arealist) self.createSetup() self["pleasewait"].hide() self["actions"].setEnabled(True)
def getFrontend(self): print("[MisPlsLcnScan][getFrontend] searching for available tuner") nimList = [] for nim in nimmanager.nim_slots: if not nim.isCompatible("DVB-S") or \ not nim.isMultistream() or \ nim.isFBCLink() or \ (hasattr(nim, 'config_mode_dvbs') and nim.config_mode_dvbs or nim.config_mode) in ("loopthrough", "satposdepends", "nothing") or \ self.transpondercurrent.orbital_position not in [sat[0] for sat in nimmanager.getSatListForNim(nim.slot)]: continue nimList.append(nim.slot) if len(nimList) == 0: print("[MisPlsLcnScan][getFrontend] No compatible tuner found") self.showError(_('No compatible tuner found')) return resmanager = eDVBResourceManager.getInstance() if not resmanager: print( "[MisPlsLcnScan][getFrontend] Cannot retrieve Resource Manager instance" ) self.showError(_('Cannot retrieve Resource Manager instance')) return # stop pip if running if self.session.pipshown: self.session.pipshown = False del self.session.pip print("[MisPlsLcnScan][getFrontend] Stopping PIP.") # stop currently playing service if it is using a tuner in ("loopthrough", "satposdepends") currentlyPlayingNIM = None currentService = self.session and self.session.nav.getCurrentService() frontendInfo = currentService and currentService.frontendInfo() frontendData = frontendInfo and frontendInfo.getAll(True) if frontendData is not None: currentlyPlayingNIM = frontendData.get("tuner_number", None) if currentlyPlayingNIM is not None and nimmanager.nim_slots[ currentlyPlayingNIM].isCompatible("DVB-S"): nimConfigMode = hasattr( nimmanager.nim_slots[currentlyPlayingNIM], "config_mode_dvbs" ) and nimmanager.nim_slots[ currentlyPlayingNIM].config_mode_dvbs or nimmanager.nim_slots[ currentlyPlayingNIM].config_mode if nimConfigMode in ("loopthrough", "satposdepends"): self.postScanService = self.session.nav.getCurrentlyPlayingServiceReference( ) self.session.nav.stopService() currentlyPlayingNIM = None print( "[MisPlsLcnScan][getFrontend] The active service was using a %s tuner, so had to be stopped (slot id %s)." % (nimConfigMode, currentlyPlayingNIM)) del frontendInfo del currentService current_slotid = -1 if self.rawchannel: del (self.rawchannel) self.frontend = None self.rawchannel = None nimList = [ slot for slot in nimList if not self.isRotorSat(slot, self.transpondercurrent.orbital_position) ] + [ slot for slot in nimList if self.isRotorSat(slot, self.transpondercurrent.orbital_position) ] #If we have a choice of dishes try "fixed" before "motorised". for slotid in nimList: if current_slotid == -1: # mark the first valid slotid in case of no other one is free current_slotid = slotid self.rawchannel = resmanager.allocateRawChannel(slotid) if self.rawchannel: print( "[MisPlsLcnScan][getFrontend] Nim found on slot id %d with sat %s" % (slotid, nimmanager.getSatName( self.transpondercurrent.orbital_position))) current_slotid = slotid break if self.rawchannel: break if current_slotid == -1: print("[MisPlsLcnScan][getFrontend] No valid NIM found") self.showError( _('No valid NIM found for %s') % PROVIDERS[config.plugins.MisPlsLcnScan.provider.value]["name"]) return if not self.rawchannel: # if we are here the only possible option is to close the active service if currentlyPlayingNIM in nimList: slotid = currentlyPlayingNIM print( "[MisPlsLcnScan][getFrontend] Nim found on slot id %d but it's busy. Stopping active service" % slotid) self.postScanService = self.session.nav.getCurrentlyPlayingServiceReference( ) self.session.nav.stopService() self.rawchannel = resmanager.allocateRawChannel(slotid) if self.rawchannel: print( "[MisPlsLcnScan][getFrontend] The active service was stopped, and the NIM is now free to use." ) current_slotid = slotid if not self.rawchannel: if self.session.nav.RecordTimer.isRecording(): print( "[MisPlsLcnScan][getFrontend] Cannot free NIM because a recording is in progress" ) self.showError( _('Cannot free NIM because a recording is in progress') ) return else: print("[MisPlsLcnScan][getFrontend] Cannot get the NIM") self.showError(_('Cannot get the NIM')) return # set extended timeout for rotors self.motorised = False if self.isRotorSat(current_slotid, self.transpondercurrent.orbital_position): self.motorised = True self.LOCK_TIMEOUT = self.LOCK_TIMEOUT_ROTOR print( "[MisPlsLcnScan][getFrontend] Motorised dish. Will wait up to %i seconds for tuner lock." % (self.LOCK_TIMEOUT // 10)) else: self.LOCK_TIMEOUT = self.LOCK_TIMEOUT_FIXED print( "[MisPlsLcnScan][getFrontend] Fixed dish. Will wait up to %i seconds for tuner lock." % (self.LOCK_TIMEOUT // 10)) self.selectedNIM = current_slotid # Remember for downloading SI tables self["tuner_text"].setText(chr(ord('A') + current_slotid)) self.frontend = self.rawchannel.getFrontend() if not self.frontend: print("[MisPlsLcnScan][getFrontend] Cannot get frontend") self.showError(_('Cannot get frontend')) return self.demuxer_id = self.rawchannel.reserveDemux() if self.demuxer_id < 0: print("[MisPlsLcnScan][getFrontend] Cannot allocate the demuxer.") self.showError(_('Cannot allocate the demuxer.')) return params_fe = eDVBFrontendParameters() params_fe.setDVBS(self.transpondercurrent, False) # try: # self.rawchannel.requestTsidOnid() # except (TypeError): # # for compatibility with some third party images # self.rawchannel.requestTsidOnid(self.gotTsidOnid) self.frontend.tune(params_fe) self.lockcounter = 0 self.locktimer = eTimer() self.locktimer.callback.append(self.checkTunerLock) self.locktimer.start(100, 1)