X-Git-Url: http://code.vuplus.com/gitweb/?p=vuplus_dvbapp;a=blobdiff_plain;f=lib%2Fpython%2FPlugins%2FSystemPlugins%2FBlindscan%2Fplugin.py;h=3ab1368d9346d3ba49e696153a9d8be5dcd7e5a9;hp=ecacfdd28a3402240e6bd5aa45e45bee9879e857;hb=ea2f1192f5595f67aa225f90767a3037b2c119b1;hpb=8cb53cea05bb033d9494eb5eade305f79506c842 diff --git a/lib/python/Plugins/SystemPlugins/Blindscan/plugin.py b/lib/python/Plugins/SystemPlugins/Blindscan/plugin.py index ecacfdd..3ab1368 100644 --- a/lib/python/Plugins/SystemPlugins/Blindscan/plugin.py +++ b/lib/python/Plugins/SystemPlugins/Blindscan/plugin.py @@ -16,249 +16,107 @@ from Components.config import config, ConfigSubsection, ConfigSelection, ConfigY from Tools.HardwareInfo import HardwareInfo from Tools.Directories import resolveFilename, SCOPE_DEFAULTPARTITIONMOUNTDIR, SCOPE_DEFAULTDIR, SCOPE_DEFAULTPARTITION -from enigma import eTimer, eDVBFrontendParametersSatellite, eComponentScan, eDVBSatelliteEquipmentControl, eDVBFrontendParametersTerrestrial, eDVBFrontendParametersCable, eConsoleAppContainer, eDVBResourceManager - -class SatBlindscanSearchSupport: - def blindTransponderSearchSessionClosed(self, *val): - self.blind_search_container.appClosed.remove(self.blindScanSearchClosed) - self.blind_search_container.dataAvail.remove(self.getBlindTransponderData) - if val and len(val): - if val[0]: - self.tlist = self.__tlist - print self.__tlist - if self.frontend: - self.frontend = None - del self.raw_channel - - self.blind_search_container.sendCtrlC() - import time - time.sleep(2) - - self.blind_search_container = None - self.blind_search_container = None - self.__tlist = None - - if self.tlist is None: - self.tlist = [] - else: - self.startScan(self.tlist, self.flags, self.feid) - - def blindScanSearchClosed(self, retval): - self.blind_search_session.close(True) - - def getBlindTransponderData(self, str): - str = self.remainingdata + str - #split in lines - lines = str.split('\n') - #'str' should end with '\n', so when splitting, the last line should be empty. If this is not the case, we received an incomplete line - if len(lines[-1]): - #remember this data for next time - self.remainingdata = lines[-1] - lines = lines[0:-1] - else: - self.remainingdata = "" - - for line in lines: - data = line.split() - if len(data): - print data - if data[0] == 'OK': - parm = eDVBFrontendParametersSatellite() - sys = { "DVB-S" : eDVBFrontendParametersSatellite.System_DVB_S, - "DVB-S2" : eDVBFrontendParametersSatellite.System_DVB_S2 } - qam = { "QPSK" : parm.Modulation_QPSK, - "8PSK" : parm.Modulation_8PSK } - inv = { "INVERSION_OFF" : parm.Inversion_Off, - "INVERSION_ON" : parm.Inversion_On, - "INVERSION_AUTO" : parm.Inversion_Unknown } - fec = { "FEC_AUTO" : parm.FEC_Auto, - "FEC_1_2" : parm.FEC_1_2, - "FEC_2_3" : parm.FEC_2_3, - "FEC_3_4" : parm.FEC_3_4, - "FEC_5_6": parm.FEC_5_6, - "FEC_7_8" : parm.FEC_7_8, - "FEC_8_9" : parm.FEC_8_9, - "FEC_3_5" : parm.FEC_3_5, - "FEC_9_10" : parm.FEC_9_10, - "FEC_NONE" : parm.FEC_None } - roll = { "ROLLOFF_20" : parm.RollOff_alpha_0_20, - "ROLLOFF_25" : parm.RollOff_alpha_0_25, - "ROLLOFF_35" : parm.RollOff_alpha_0_35 } - pilot = { "PILOT_ON" : parm.Pilot_On, - "PILOT_OFF" : parm.Pilot_Off } - pol = { "HORIZONTAL" : parm.Polarisation_Horizontal, - "VERTICAL" : parm.Polarisation_Vertical } - - sat = self.satList[0][self.scan_satselection[0].index] - parm.orbital_position = sat[0] - - parm.polarisation = pol[data[1]] - parm.frequency = int(data[2]) - parm.symbol_rate = int(data[3]) - parm.system = sys[data[4]] - parm.inversion = inv[data[5]] - parm.pilot = pilot[data[6]] - parm.fec = fec[data[7]] - parm.modulation = qam[data[8]] - parm.rolloff = roll[data[9]] - self.__tlist.append(parm) - flags = None - - def openFrontend(self): - res_mgr = eDVBResourceManager.getInstance() - if res_mgr: - self.raw_channel = res_mgr.allocateRawChannel(self.feid) - if self.raw_channel: - self.frontend = self.raw_channel.getFrontend() - if self.frontend: - return True - else: - print "getFrontend failed" - else: - print "getRawChannel failed" - else: - print "getResourceManager instance failed" - return False +from enigma import eTimer, eDVBFrontendParametersSatellite, eComponentScan, eDVBSatelliteEquipmentControl, eDVBFrontendParametersTerrestrial, eDVBFrontendParametersCable, eConsoleAppContainer, eDVBResourceManager, getDesktop - def startSatBlindscanSearch(self, nim_idx, orbpos, session): - if self.blindscan_start_frequency.value < 950*1000000 or self.blindscan_start_frequency.value > 2150*1000000 : - self.session.open(MessageBox, _("Please check again.\nStart frequency must be between 950 and 2150."), MessageBox.TYPE_ERROR) - return - if self.blindscan_stop_frequency.value < 950*1000000 or self.blindscan_stop_frequency.value > 2150*1000000 : - self.session.open(MessageBox, _("Please check again.\nStop frequency must be between 950 and 2150."), MessageBox.TYPE_ERROR) - return - if self.blindscan_start_frequency.value > self.blindscan_stop_frequency.value : - self.session.open(MessageBox, _("Please check again.\nFrequency : start value is larger than stop value."), MessageBox.TYPE_ERROR) - return - if self.blindscan_start_symbol.value < 2*1000000 or self.blindscan_start_symbol.value > 45*1000000 : - self.session.open(MessageBox, _("Please check again.\nStart symbolrate must be between 2MHz and 45MHz."), MessageBox.TYPE_ERROR) - return - if self.blindscan_stop_symbol.value < 2*1000000 or self.blindscan_stop_symbol.value > 45*1000000 : - self.session.open(MessageBox, _("Please check again.\nStop symbolrate must be between 2MHz and 45MHz."), MessageBox.TYPE_ERROR) - return - if self.blindscan_start_symbol.value > self.blindscan_stop_symbol.value : - self.session.open(MessageBox, _("Please check again.\nSymbolrate : start value is larger than stop value."), MessageBox.TYPE_ERROR) - return - - self.__tlist = [ ] - self.remainingdata = "" - self.feid = nim_idx - if not self.openFrontend(): - self.oldref = session.nav.getCurrentlyPlayingServiceReference() - session.nav.stopService() # try to disable foreground service - if not self.openFrontend(): - if session.pipshown: # try to disable pip - session.pipshown = False - del session.pip - if not self.openFrontend(): - self.frontend = None # in normal case this should not happen - - self.tuner = Tuner(self.frontend) - sat = self.satList[0][self.scan_satselection[0].index] +class Blindscan(ConfigListScreen, Screen): + skin = """ + + + + - tab_hilow = {"high" : 1, "low" : 0} - returnvalue = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0) - if tab_hilow[self.blindscan_hi.value]: - self.scan_sat.frequency.value = 12515 - else: - self.scan_sat.frequency.value = 11015 - returnvalue = (self.scan_sat.frequency.value, - 0, - self.scan_sat.polarization.value, - 0, - 0, - int(orbpos[0]), - eDVBFrontendParametersSatellite.System_DVB_S, - 0, - 0, - 0) - self.tuner.tune(returnvalue) + + + - self.blind_search_container = eConsoleAppContainer() - self.blind_search_container.appClosed.append(self.blindScanSearchClosed) - self.blind_search_container.dataAvail.append(self.getBlindTransponderData) - cmd = "/usr/lib/enigma2/python/Plugins/SystemPlugins/Blindscan/vuplus_blindscan %d %d %d %d %d %d %d" % (self.blindscan_start_frequency.value/1000000, self.blindscan_stop_frequency.value/1000000, self.blindscan_start_symbol.value/1000000, self.blindscan_stop_symbol.value/1000000, self.scan_sat.polarization.value, tab_hilow[self.blindscan_hi.value], self.feid) - print "prepared command : ", cmd - self.blind_search_container.execute(cmd) - - tmpstr = _("Blindscan takes some minute.") - self.blind_search_session = self.session.openWithCallback(self.blindTransponderSearchSessionClosed, MessageBox, tmpstr, MessageBox.TYPE_INFO) - -class Blindscan(ConfigListScreen, Screen, SatBlindscanSearchSupport): - skin=""" - - - - - - - - + + """ + def __init__(self, session): Screen.__init__(self, session) - self.updateSatList() - self.service = session.nav.getCurrentService() self.current_play_service = self.session.nav.getCurrentlyPlayingServiceReference() - self.feinfo = None - self.networkid = 0 - frontendData = None - if self.service is not None: - self.feinfo = self.service.frontendInfo() - frontendData = self.feinfo and self.feinfo.getAll(True) - - self.createConfig(frontendData) - - del self.feinfo - del self.service - self["actions"] = ActionMap(["OkCancelActions", "ShortcutActions", "WizardActions", "ColorActions", "SetupActions", ], - { - "red": self.keyCancel, - "green": self.keyGo, - "ok": self.keyGo, - "cancel": self.keyCancel, - }, -2) + # 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.updateStatus) + # make config + self.createConfig() self.list = [] + self.status = "" + ConfigListScreen.__init__(self, self.list) - - self["key_red"] = StaticText(_("Exit")) - self["key_green"] = StaticText("Start") - - #if not self.scan_nims.value == "": - # self.createSetup() - try: - if not self.scan_nims.value == "": - self.createSetup() - except: + 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.makeNimSocket() + + def makeNimSocket(self): + self.i2c_mapping_table = {0:2, 1:3, 2:1, 3:0} + + def getNimSocket(self, slot_number): + if slot_number < 0 or slot_number > 3: + return -1 + return self.i2c_mapping_table[slot_number] def keyNone(self): None - - def updateSatList(self): - self.satList = [] - for slot in nimmanager.nim_slots: - if slot.isCompatible("DVB-S"): - self.satList.append(nimmanager.getSatListForNim(slot.slot)) + def callbackNone(self, *retval): + None + + def openFrontend(self): + res_mgr = eDVBResourceManager.getInstance() + if res_mgr: + self.raw_channel = res_mgr.allocateRawChannel(self.feid) + if self.raw_channel: + self.frontend = self.raw_channel.getFrontend() + if self.frontend: + return True + else: + print "getFrontend failed" else: - self.satList.append(None) + print "getRawChannel failed" + else: + print "getResourceManager instance failed" + return False - def createConfig(self, frontendData): + def createConfig(self): + self.feinfo = None + frontendData = None defaultSat = { "orbpos": 192, "system": eDVBFrontendParametersSatellite.System_DVB_S, @@ -268,7 +126,13 @@ class Blindscan(ConfigListScreen, Screen, SatBlindscanSearchSupport): "polarization": eDVBFrontendParametersSatellite.Polarisation_Horizontal, "fec": eDVBFrontendParametersSatellite.FEC_Auto, "fec_s2": eDVBFrontendParametersSatellite.FEC_9_10, - "modulation": eDVBFrontendParametersSatellite.Modulation_QPSK } + "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": @@ -285,21 +149,26 @@ class Blindscan(ConfigListScreen, Screen, SatBlindscanSearchSupport): 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) # blindscan add - self.blindscan_hi = ConfigSelection(default = "low", choices = [("low", _("low")), ("high", _("high"))]) + self.blindscan_hi = ConfigSelection(default = "hi_low", choices = [("low", _("low")), ("high", _("high")), ("hi_low", _("hi_low"))]) #ConfigYesNo(default = True) self.blindscan_start_frequency = ConfigInteger(default = 950*1000000) self.blindscan_stop_frequency = ConfigInteger(default = 2150*1000000) self.blindscan_start_symbol = ConfigInteger(default = 2*1000000) self.blindscan_stop_symbol = ConfigInteger(default = 45*1000000) + self.scan_clearallservices = ConfigYesNo(default = False) + self.scan_onlyfree = ConfigYesNo(default = False) - nim_list = [] # collect all nims which are *not* set to "nothing" + nim_list = [] for n in nimmanager.nim_slots: if n.config_mode == "nothing": continue @@ -309,21 +178,15 @@ class Blindscan(ConfigListScreen, Screen, SatBlindscanSearchSupport): 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)) - + if n.isCompatible("DVB-S"): + 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.frequency = ConfigInteger(default = defaultSat["frequency"], limits = (1, 99999)) - self.scan_sat.polarization = ConfigSelection(default = defaultSat["polarization"], choices = [ + #self.scan_sat.polarization = ConfigSelection(default = defaultSat["polarization"], choices = [ + self.scan_sat.polarization = ConfigSelection(default = eDVBFrontendParametersSatellite.Polarisation_CircularRight + 1, choices = [ + (eDVBFrontendParametersSatellite.Polarisation_CircularRight + 1, _("horizontal_vertical")), (eDVBFrontendParametersSatellite.Polarisation_Horizontal, _("horizontal")), (eDVBFrontendParametersSatellite.Polarisation_Vertical, _("vertical")), (eDVBFrontendParametersSatellite.Polarisation_CircularLeft, _("circular left")), @@ -336,10 +199,48 @@ class Blindscan(ConfigListScreen, Screen, SatBlindscanSearchSupport): 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 getSelectedSatIndex(self, v): + index = 0 + none_cnt = 0 + for n in self.satList: + if self.satList[index] == None: + none_cnt = none_cnt + 1 + if index == int(v): + return (index-none_cnt) + index = index + 1 + return -1 + + 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.systemEntry = None + self.modulationEntry = None + nim = nimmanager.nim_slots[index_to_scan] + + self.scan_networkScan.value = False + if nim.isCompatible("DVB-S") : + self.list.append(getConfigListEntry(_('Satellite'), self.scan_satselection[self.getSelectedSatIndex(index_to_scan)])) + self.list.append(getConfigListEntry(_('Scan start frequency'), self.blindscan_start_frequency)) + self.list.append(getConfigListEntry(_('Scan stop frequency'), self.blindscan_stop_frequency)) + self.list.append(getConfigListEntry(_("Polarity"), self.scan_sat.polarization)) + self.list.append(getConfigListEntry(_("Scan band"), self.blindscan_hi)) + self.list.append(getConfigListEntry(_('Scan start symbolrate'), self.blindscan_start_symbol)) + self.list.append(getConfigListEntry(_('Scan stop symbolrate'), self.blindscan_stop_symbol)) + 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 newConfig(self): cur = self["config"].getCurrent() @@ -349,6 +250,27 @@ class Blindscan(ConfigListScreen, Screen, SatBlindscanSearchSupport): (self.modulationEntry and self.systemEntry[1].value == eDVBFrontendParametersSatellite.System_DVB_S2 and cur == self.modulationEntry): self.createSetup() + def checkSettings(self): + if self.blindscan_start_frequency.value < 950*1000000 or self.blindscan_start_frequency.value > 2150*1000000 : + self.session.open(MessageBox, _("Please check again.\nStart frequency must be between 950 and 2150."), MessageBox.TYPE_ERROR) + return False + if self.blindscan_stop_frequency.value < 950*1000000 or self.blindscan_stop_frequency.value > 2150*1000000 : + self.session.open(MessageBox, _("Please check again.\nStop frequency must be between 950 and 2150."), MessageBox.TYPE_ERROR) + return False + if self.blindscan_start_frequency.value > self.blindscan_stop_frequency.value : + self.session.open(MessageBox, _("Please check again.\nFrequency : start value is larger than stop value."), MessageBox.TYPE_ERROR) + return False + if self.blindscan_start_symbol.value < 2*1000000 or self.blindscan_start_symbol.value > 45*1000000 : + self.session.open(MessageBox, _("Please check again.\nStart symbolrate must be between 2MHz and 45MHz."), MessageBox.TYPE_ERROR) + return False + if self.blindscan_stop_symbol.value < 2*1000000 or self.blindscan_stop_symbol.value > 45*1000000 : + self.session.open(MessageBox, _("Please check again.\nStop symbolrate must be between 2MHz and 45MHz."), MessageBox.TYPE_ERROR) + return False + if self.blindscan_start_symbol.value > self.blindscan_stop_symbol.value : + self.session.open(MessageBox, _("Please check again.\nSymbolrate : start value is larger than stop value."), MessageBox.TYPE_ERROR) + return False + return True + def keyLeft(self): ConfigListScreen.keyLeft(self) self.newConfig() @@ -356,82 +278,245 @@ class Blindscan(ConfigListScreen, Screen, SatBlindscanSearchSupport): def keyRight(self): ConfigListScreen.keyRight(self) self.newConfig() - - def updateStatus(self): - print "updatestatus" - - def keyGo(self): - if self.scan_nims.value == "": - return - tlist = [] - flags = None - 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" - else: - print "is not compatible with DVB-S" - return - - flags = self.scan_networkScan.value and eComponentScan.scanNetworkSearch or 0 - for x in self["config"].list: - x[1].save() - - self.flags = flags - self.feid = index_to_scan - self.tlist = [] - orbpos = self.satList[index_to_scan][self.scan_satselection[index_to_scan].index] - self.startSatBlindscanSearch(index_to_scan, orbpos, self.session) def keyCancel(self): + self.session.nav.playService(self.current_play_service) for x in self["config"].list: x[1].cancel() - self.session.nav.playService(self.current_play_service) self.close() - def startScan(self, tlist, flags, feid, networkid = 0): - if len(tlist): - self.session.open(ServiceScan, [{"transponders": tlist, "feid": feid, "flags": flags, "networkid": networkid}]) - else: - self.session.open(MessageBox, _("Nothing to scan!\nPlease setup your tuner settings before you start a service scan."), MessageBox.TYPE_ERROR) + def keyGo(self): + if self.checkSettings() == False: + return - def createSetup(self): - self.list = [] - self.multiscanlist = [] - index_to_scan = int(self.scan_nims.value) - print "ID: ", index_to_scan + tab_pol = { + eDVBFrontendParametersSatellite.Polarisation_Horizontal : "horizontal", + eDVBFrontendParametersSatellite.Polarisation_Vertical : "vertical", + eDVBFrontendParametersSatellite.Polarisation_CircularLeft : "circular left", + eDVBFrontendParametersSatellite.Polarisation_CircularRight : "circular right", + eDVBFrontendParametersSatellite.Polarisation_CircularRight + 1 : "horizontal_vertical" + } + + self.tmp_tplist=[] + tmp_pol = [] + tmp_band = [] + idx_selected_sat = int(self.getSelectedSatIndex(self.scan_nims.value)) + tmp_list=[self.satList[int(self.scan_nims.value)][self.scan_satselection[idx_selected_sat].index]] + + if self.blindscan_hi.value == "hi_low" : + tmp_band=["low","high"] + else: + tmp_band=[self.blindscan_hi.value] + + if self.scan_sat.polarization.value == eDVBFrontendParametersSatellite.Polarisation_CircularRight + 1 : + tmp_pol=["horizontal","vertical"] + else: + tmp_pol=[tab_pol[self.scan_sat.polarization.value]] - self.tunerEntry = getConfigListEntry(_("Tuner"), self.scan_nims) - self.list.append(self.tunerEntry) + self.doRun(tmp_list, tmp_pol, tmp_band) - if self.scan_nims == [ ]: + def keyGoAll(self): + if self.checkSettings() == False: return + self.tmp_tplist=[] + tmp_list=[] + tmp_band=["low","high"] + tmp_pol=["horizontal","vertical"] - self.systemEntry = None - self.modulationEntry = None - nim = nimmanager.nim_slots[index_to_scan] + for slot in nimmanager.nim_slots: + device_name = "/dev/dvb/adapter0/frontend%d" % (slot.slot) + if slot.isCompatible("DVB-S") and int(self.scan_nims.value) == slot.slot: + for s in self.satList[slot.slot]: + tmp_list.append(s) + self.doRun(tmp_list, tmp_pol, tmp_band) - self.scan_networkScan.value = False - if nim.isCompatible("DVB-S") : - self.list.append(getConfigListEntry(_('Satellite'), self.scan_satselection[index_to_scan])) - self.list.append(getConfigListEntry(_('Scan start frequency'), self.blindscan_start_frequency)) - self.list.append(getConfigListEntry(_('Scan stop frequency'), self.blindscan_stop_frequency)) - self.list.append(getConfigListEntry(_("Polarity"), self.scan_sat.polarization)) - self.list.append(getConfigListEntry(_("Scan band"), self.blindscan_hi)) - self.list.append(getConfigListEntry(_('Scan start symbolrate'), self.blindscan_start_symbol)) - self.list.append(getConfigListEntry(_('Scan stop symbolrate'), self.blindscan_stop_symbol)) - self["config"].list = self.list - self["config"].l.setList(self.list) + def doRun(self, tmp_list, tmp_pol, tmp_band): + self.full_data = "" + self.total_list=[] + for x in tmp_list: + for y in tmp_pol: + for z in tmp_band: + self.total_list.append([x,y,z]) + print "add scan item : ", x, ", ", y, ", ", z + + self.max_count = len(self.total_list) + self.is_runable = True + self.running_count = 0 + self.clockTimer = eTimer() + self.clockTimer.callback.append(self.doClock) + self.clockTimer.start(1000) + + def doClock(self): + is_scan = False + if self.is_runable : + if self.running_count >= self.max_count: + self.clockTimer.stop() + del self.clockTimer + self.clockTimer = None + print "Done" + return + orb = self.total_list[self.running_count][0] + pol = self.total_list[self.running_count][1] + band = self.total_list[self.running_count][2] + self.running_count = self.running_count + 1 + print "running status-[%d] : [%d][%s][%s]" %(self.running_count, orb[0], pol, band) + if self.running_count == self.max_count: + is_scan = True + self.prepareScanData(orb, pol, band, is_scan) + + def prepareScanData(self, orb, pol, band, is_scan): + self.is_runable = False + self.orb_position = orb[0] + self.feid = int(self.scan_nims.value) + tab_hilow = {"high" : 1, "low" : 0} + tab_pol = { + "horizontal" : eDVBFrontendParametersSatellite.Polarisation_Horizontal, + "vertical" : eDVBFrontendParametersSatellite.Polarisation_Vertical, + "circular left" : eDVBFrontendParametersSatellite.Polarisation_CircularLeft, + "circular right" : eDVBFrontendParametersSatellite.Polarisation_CircularRight + } + + returnvalue = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0) + + if not self.openFrontend(): + self.oldref = self.session.nav.getCurrentlyPlayingServiceReference() + self.session.nav.stopService() + if not self.openFrontend(): + if self.session.pipshown: + self.session.pipshown = False + del self.session.pip + if not self.openFrontend(): + self.frontend = None + self.tuner = Tuner(self.frontend) + + if tab_hilow[band]: + self.scan_sat.frequency.value = 12515 else: - self.session.open(MessageBox, _("Please setup DVB-S Tuner"), MessageBox.TYPE_ERROR) + self.scan_sat.frequency.value = 11015 + returnvalue = (self.scan_sat.frequency.value, + 0, + tab_pol[pol], + 0, + 0, + orb[0], + eDVBFrontendParametersSatellite.System_DVB_S, + 0, + 0, + 0) + self.tuner.tune(returnvalue) + + if self.getNimSocket(self.feid) < 0: + print "can't find i2c number!!" + return + + cmd = "vuplus_blindscan %d %d %d %d %d %d %d %d" % (self.blindscan_start_frequency.value/1000000, self.blindscan_stop_frequency.value/1000000, self.blindscan_start_symbol.value/1000000, self.blindscan_stop_symbol.value/1000000, tab_pol[pol], tab_hilow[band], self.feid, self.getNimSocket(self.feid)) + print "prepared command : [%s]" % (cmd) + self.blindscan_container = eConsoleAppContainer() + self.blindscan_container.appClosed.append(self.blindscanContainerClose) + self.blindscan_container.dataAvail.append(self.blindscanContainerAvail) + self.blindscan_container.execute(cmd) + + tmpstr = "Look for available transponders.\nThis works will take several minutes.\n\n - Current Status : %d/%d\n - Orbital Positions : %s\n - Polarization : %s\n - Bandwidth : %s" %(self.running_count, self.max_count, orb[1], pol, band) + if is_scan : + self.blindscan_session = self.session.openWithCallback(self.blindscanSessionClose, MessageBox, _(tmpstr), MessageBox.TYPE_INFO) + else: + self.blindscan_session = self.session.openWithCallback(self.blindscanSessionNone, MessageBox, _(tmpstr), MessageBox.TYPE_INFO) + + def blindscanContainerClose(self, retval): + lines = self.full_data.split('\n') + for line in lines: + data = line.split() + print "cnt :", len(data), ", data :", data + if len(data) >= 10: + if data[0] == 'OK': + parm = eDVBFrontendParametersSatellite() + sys = { "DVB-S" : eDVBFrontendParametersSatellite.System_DVB_S, + "DVB-S2" : eDVBFrontendParametersSatellite.System_DVB_S2} + qam = { "QPSK" : parm.Modulation_QPSK, + "8PSK" : parm.Modulation_8PSK} + inv = { "INVERSION_OFF" : parm.Inversion_Off, + "INVERSION_ON" : parm.Inversion_On, + "INVERSION_AUTO" : parm.Inversion_Unknown} + fec = { "FEC_AUTO" : parm.FEC_Auto, + "FEC_1_2" : parm.FEC_1_2, + "FEC_2_3" : parm.FEC_2_3, + "FEC_3_4" : parm.FEC_3_4, + "FEC_5_6": parm.FEC_5_6, + "FEC_7_8" : parm.FEC_7_8, + "FEC_8_9" : parm.FEC_8_9, + "FEC_3_5" : parm.FEC_3_5, + "FEC_9_10" : parm.FEC_9_10, + "FEC_NONE" : parm.FEC_None} + roll ={ "ROLLOFF_20" : parm.RollOff_alpha_0_20, + "ROLLOFF_25" : parm.RollOff_alpha_0_25, + "ROLLOFF_35" : parm.RollOff_alpha_0_35} + pilot={ "PILOT_ON" : parm.Pilot_On, + "PILOT_OFF" : parm.Pilot_Off} + pol = { "HORIZONTAL" : parm.Polarisation_Horizontal, + "VERTICAL" : parm.Polarisation_Vertical} + try : + parm.orbital_position = self.orb_position + parm.polarisation = pol[data[1]] + parm.frequency = int(data[2]) + parm.symbol_rate = int(data[3]) + parm.system = sys[data[4]] + parm.inversion = inv[data[5]] + parm.pilot = pilot[data[6]] + parm.fec = fec[data[7]] + parm.modulation = qam[data[8]] + parm.rolloff = roll[data[9]] + self.tmp_tplist.append(parm) + except: + pass + self.blindscan_session.close(True) + + def blindscanContainerAvail(self, str): + print str + #if str.startswith("OK"): + self.full_data = self.full_data + str + + def blindscanSessionNone(self, *val): + import time + self.blindscan_container.sendCtrlC() + self.blindscan_container = None + time.sleep(2) + + if self.frontend: + self.frontend = None + del self.raw_channel + + if val[0] == False: + self.tmp_tplist = [] + self.running_count = self.max_count + + self.is_runable = True + def blindscanSessionClose(self, *val): + self.blindscanSessionNone(val[0]) + + if self.tmp_tplist != None and self.tmp_tplist != []: + for p in self.tmp_tplist: + print "data : [%d][%d][%d][%d][%d][%d][%d][%d][%d][%d]" % (p.orbital_position, p.polarisation, p.frequency, p.symbol_rate, p.system, p.inversion, p.pilot, p.fec, p.modulation, p.modulation) + + self.startScan(self.tmp_tplist, self.feid) + else: + msg = "No found transponders!!\nPlease check the satellite connection, or scan other search condition." + if val[0] == False: + msg = "Blindscan was canceled by the user." + self.session.openWithCallback(self.callbackNone, MessageBox, _(msg), MessageBox.TYPE_INFO, timeout=10) + self.tmp_tplist = [] + + def startScan(self, tlist, feid, networkid = 0): + self.scan_session = None + + flags = 0 + if self.scan_clearallservices.value: + flags |= eComponentScan.scanRemoveServices + else: + flags |= eComponentScan.scanDontRemoveUnscanned + if self.scan_onlyfree.value: + flags |= eComponentScan.scanOnlyFree + self.session.open(ServiceScan, [{"transponders": tlist, "feid": feid, "flags": flags, "networkid": networkid}]) def main(session, **kwargs): session.open(Blindscan)