1 from Plugins.Plugin import PluginDescriptor
3 from Screens.Screen import Screen
4 from Screens.ServiceScan import ServiceScan
5 from Screens.MessageBox import MessageBox
6 from Screens.DefaultWizard import DefaultWizard
8 from Components.Label import Label
9 from Components.TuneTest import Tuner
10 from Components.ConfigList import ConfigListScreen
11 from Components.Sources.StaticText import StaticText
12 from Components.ActionMap import NumberActionMap, ActionMap
13 from Components.NimManager import nimmanager, getConfigSatlist
14 from Components.config import config, ConfigSubsection, ConfigSelection, ConfigYesNo, ConfigInteger, getConfigListEntry, ConfigSlider, ConfigEnableDisable
16 from Tools.HardwareInfo import HardwareInfo
17 from Tools.Directories import resolveFilename, SCOPE_DEFAULTPARTITIONMOUNTDIR, SCOPE_DEFAULTDIR, SCOPE_DEFAULTPARTITION
19 from enigma import eTimer, eDVBFrontendParametersSatellite, eComponentScan, eDVBSatelliteEquipmentControl, eDVBFrontendParametersTerrestrial, eDVBFrontendParametersCable, eConsoleAppContainer, eDVBResourceManager
21 class Blindscan(ConfigListScreen, Screen):
23 <screen name="Blindscan" position="center,center" size="560,370" title="Blindscan">
24 <ePixmap pixmap="Vu_HD/buttons/red.png" position="5,0" size="80,40" alphatest="on" />
25 <ePixmap pixmap="Vu_HD/buttons/green.png" position="186,0" size="80,40" alphatest="on" />
26 <ePixmap pixmap="Vu_HD/buttons/blue.png" position="372,0" size="80,40" alphatest="on" />
28 <widget source="key_red" render="Label" position="28,0" zPosition="1" size="160,30" font="Regular;20" halign="center" valign="center" transparent="1"/>
29 <widget source="key_green" render="Label" position="213,0" zPosition="1" size="160,30" font="Regular;20" halign="center" valign="center" transparent="1"/>
30 <widget source="key_blue" render="Label" position="400,0" zPosition="1" size="160,30" font="Regular;20" halign="center" valign="center" transparent="1"/>
32 <widget name="config" position="5,50" size="550,280" scrollbarMode="showOnDemand" />
33 <widget name="introduction" position="0,345" size="560,20" font="Regular;20" halign="center" />
36 def __init__(self, session):
37 Screen.__init__(self, session)
39 self.current_play_service = self.session.nav.getCurrentlyPlayingServiceReference()
43 for slot in nimmanager.nim_slots:
44 if slot.isCompatible("DVB-S"):
45 self.satList.append(nimmanager.getSatListForNim(slot.slot))
47 self.satList.append(None)
55 ConfigListScreen.__init__(self, self.list)
56 if self.scan_nims.value != None and self.scan_nims.value != "" :
57 self["actions"] = ActionMap(["OkCancelActions", "ShortcutActions", "WizardActions", "ColorActions", "SetupActions", ],
59 "red": self.keyCancel,
63 "cancel": self.keyCancel,
65 self["key_red"] = StaticText(_("Exit"))
66 self["key_green"] = StaticText("Scan")
67 self["key_blue"] = StaticText("Scan All")
68 self["introduction"] = Label(_("Press Green/OK to start the scan"))
71 self["actions"] = ActionMap(["OkCancelActions", "ShortcutActions", "WizardActions", "ColorActions", "SetupActions", ],
73 "red": self.keyCancel,
74 "green": self.keyNone,
77 "cancel": self.keyCancel,
79 self["key_red"] = StaticText(_("Exit"))
80 self["key_green"] = StaticText(" ")
81 self["key_blue"] = StaticText(" ")
82 self["introduction"] = Label(_("Please setup your tuner configuration."))
84 self.i2c_mapping_table = None
87 def makeNimSocket(self):
88 self.i2c_mapping_table = {0:2, 1:3, 2:1, 3:0}
90 def getNimSocket(self, slot_number):
91 if slot_number < 0 or slot_number > 3:
93 return self.i2c_mapping_table[slot_number]
97 def callbackNone(self, *retval):
100 def openFrontend(self):
101 res_mgr = eDVBResourceManager.getInstance()
103 self.raw_channel = res_mgr.allocateRawChannel(self.feid)
105 self.frontend = self.raw_channel.getFrontend()
109 print "getFrontend failed"
111 print "getRawChannel failed"
113 print "getResourceManager instance failed"
116 def createConfig(self):
121 "system": eDVBFrontendParametersSatellite.System_DVB_S,
123 "inversion": eDVBFrontendParametersSatellite.Inversion_Unknown,
125 "polarization": eDVBFrontendParametersSatellite.Polarisation_Horizontal,
126 "fec": eDVBFrontendParametersSatellite.FEC_Auto,
127 "fec_s2": eDVBFrontendParametersSatellite.FEC_9_10,
128 "modulation": eDVBFrontendParametersSatellite.Modulation_QPSK
131 self.service = self.session.nav.getCurrentService()
132 if self.service is not None:
133 self.feinfo = self.service.frontendInfo()
134 frontendData = self.feinfo and self.feinfo.getAll(True)
135 if frontendData is not None:
136 ttype = frontendData.get("tuner_type", "UNKNOWN")
138 defaultSat["system"] = frontendData.get("system", eDVBFrontendParametersSatellite.System_DVB_S)
139 defaultSat["frequency"] = frontendData.get("frequency", 0) / 1000
140 defaultSat["inversion"] = frontendData.get("inversion", eDVBFrontendParametersSatellite.Inversion_Unknown)
141 defaultSat["symbolrate"] = frontendData.get("symbol_rate", 0) / 1000
142 defaultSat["polarization"] = frontendData.get("polarization", eDVBFrontendParametersSatellite.Polarisation_Horizontal)
143 if defaultSat["system"] == eDVBFrontendParametersSatellite.System_DVB_S2:
144 defaultSat["fec_s2"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto)
145 defaultSat["rolloff"] = frontendData.get("rolloff", eDVBFrontendParametersSatellite.RollOff_alpha_0_35)
146 defaultSat["pilot"] = frontendData.get("pilot", eDVBFrontendParametersSatellite.Pilot_Unknown)
148 defaultSat["fec"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto)
149 defaultSat["modulation"] = frontendData.get("modulation", eDVBFrontendParametersSatellite.Modulation_QPSK)
150 defaultSat["orbpos"] = frontendData.get("orbital_position", 0)
155 self.scan_sat = ConfigSubsection()
156 self.scan_networkScan = ConfigYesNo(default = False)
159 self.blindscan_hi = ConfigSelection(default = "hi_low", choices = [("low", _("low")), ("high", _("high")), ("hi_low", _("hi_low"))])
161 #ConfigYesNo(default = True)
162 self.blindscan_start_frequency = ConfigInteger(default = 950*1000000)
163 self.blindscan_stop_frequency = ConfigInteger(default = 2150*1000000)
164 self.blindscan_start_symbol = ConfigInteger(default = 2*1000000)
165 self.blindscan_stop_symbol = ConfigInteger(default = 45*1000000)
166 self.scan_clearallservices = ConfigYesNo(default = False)
167 self.scan_onlyfree = ConfigYesNo(default = False)
169 # collect all nims which are *not* set to "nothing"
171 for n in nimmanager.nim_slots:
172 if n.config_mode == "nothing":
174 if n.config_mode == "advanced" and len(nimmanager.getSatListForNim(n.slot)) < 1:
176 if n.config_mode in ("loopthrough", "satposdepends"):
177 root_id = nimmanager.sec.getRoot(n.slot_id, int(n.config.connectedTo.value))
178 if n.type == nimmanager.nim_slots[root_id].type: # check if connected from a DVB-S to DVB-S2 Nim or vice versa
180 if n.isCompatible("DVB-S"):
181 nim_list.append((str(n.slot), n.friendly_full_description))
182 self.scan_nims = ConfigSelection(choices = nim_list)
185 self.scan_sat.frequency = ConfigInteger(default = defaultSat["frequency"], limits = (1, 99999))
186 #self.scan_sat.polarization = ConfigSelection(default = defaultSat["polarization"], choices = [
187 self.scan_sat.polarization = ConfigSelection(default = eDVBFrontendParametersSatellite.Polarisation_CircularRight + 1, choices = [
188 (eDVBFrontendParametersSatellite.Polarisation_CircularRight + 1, _("horizontal_vertical")),
189 (eDVBFrontendParametersSatellite.Polarisation_Horizontal, _("horizontal")),
190 (eDVBFrontendParametersSatellite.Polarisation_Vertical, _("vertical")),
191 (eDVBFrontendParametersSatellite.Polarisation_CircularLeft, _("circular left")),
192 (eDVBFrontendParametersSatellite.Polarisation_CircularRight, _("circular right"))])
193 self.scan_scansat = {}
194 for sat in nimmanager.satList:
195 self.scan_scansat[sat[0]] = ConfigYesNo(default = False)
197 self.scan_satselection = []
198 for slot in nimmanager.nim_slots:
199 if slot.isCompatible("DVB-S"):
200 self.scan_satselection.append(getConfigSatlist(defaultSat["orbpos"], self.satList[slot.slot]))
203 def getSelectedSatIndex(self, v):
206 for n in self.satList:
207 if self.satList[index] == None:
208 none_cnt = none_cnt + 1
210 return (index-none_cnt)
214 def createSetup(self):
216 self.multiscanlist = []
217 index_to_scan = int(self.scan_nims.value)
218 print "ID: ", index_to_scan
220 self.tunerEntry = getConfigListEntry(_("Tuner"), self.scan_nims)
221 self.list.append(self.tunerEntry)
223 if self.scan_nims == [ ]:
226 self.systemEntry = None
227 self.modulationEntry = None
228 nim = nimmanager.nim_slots[index_to_scan]
230 self.scan_networkScan.value = False
231 if nim.isCompatible("DVB-S") :
232 self.list.append(getConfigListEntry(_('Satellite'), self.scan_satselection[self.getSelectedSatIndex(index_to_scan)]))
233 self.list.append(getConfigListEntry(_('Scan start frequency'), self.blindscan_start_frequency))
234 self.list.append(getConfigListEntry(_('Scan stop frequency'), self.blindscan_stop_frequency))
235 self.list.append(getConfigListEntry(_("Polarity"), self.scan_sat.polarization))
236 self.list.append(getConfigListEntry(_("Scan band"), self.blindscan_hi))
237 self.list.append(getConfigListEntry(_('Scan start symbolrate'), self.blindscan_start_symbol))
238 self.list.append(getConfigListEntry(_('Scan stop symbolrate'), self.blindscan_stop_symbol))
239 self.list.append(getConfigListEntry(_("Clear before scan"), self.scan_clearallservices))
240 self.list.append(getConfigListEntry(_("Only Free scan"), self.scan_onlyfree))
241 self["config"].list = self.list
242 self["config"].l.setList(self.list)
245 cur = self["config"].getCurrent()
247 if cur == self.tunerEntry or \
248 cur == self.systemEntry or \
249 (self.modulationEntry and self.systemEntry[1].value == eDVBFrontendParametersSatellite.System_DVB_S2 and cur == self.modulationEntry):
252 def checkSettings(self):
253 if self.blindscan_start_frequency.value < 950*1000000 or self.blindscan_start_frequency.value > 2150*1000000 :
254 self.session.open(MessageBox, _("Please check again.\nStart frequency must be between 950 and 2150."), MessageBox.TYPE_ERROR)
256 if self.blindscan_stop_frequency.value < 950*1000000 or self.blindscan_stop_frequency.value > 2150*1000000 :
257 self.session.open(MessageBox, _("Please check again.\nStop frequency must be between 950 and 2150."), MessageBox.TYPE_ERROR)
259 if self.blindscan_start_frequency.value > self.blindscan_stop_frequency.value :
260 self.session.open(MessageBox, _("Please check again.\nFrequency : start value is larger than stop value."), MessageBox.TYPE_ERROR)
262 if self.blindscan_start_symbol.value < 2*1000000 or self.blindscan_start_symbol.value > 45*1000000 :
263 self.session.open(MessageBox, _("Please check again.\nStart symbolrate must be between 2MHz and 45MHz."), MessageBox.TYPE_ERROR)
265 if self.blindscan_stop_symbol.value < 2*1000000 or self.blindscan_stop_symbol.value > 45*1000000 :
266 self.session.open(MessageBox, _("Please check again.\nStop symbolrate must be between 2MHz and 45MHz."), MessageBox.TYPE_ERROR)
268 if self.blindscan_start_symbol.value > self.blindscan_stop_symbol.value :
269 self.session.open(MessageBox, _("Please check again.\nSymbolrate : start value is larger than stop value."), MessageBox.TYPE_ERROR)
274 ConfigListScreen.keyLeft(self)
278 ConfigListScreen.keyRight(self)
282 self.session.nav.playService(self.current_play_service)
283 for x in self["config"].list:
288 if self.checkSettings() == False:
292 eDVBFrontendParametersSatellite.Polarisation_Horizontal : "horizontal",
293 eDVBFrontendParametersSatellite.Polarisation_Vertical : "vertical",
294 eDVBFrontendParametersSatellite.Polarisation_CircularLeft : "circular left",
295 eDVBFrontendParametersSatellite.Polarisation_CircularRight : "circular right",
296 eDVBFrontendParametersSatellite.Polarisation_CircularRight + 1 : "horizontal_vertical"
302 idx_selected_sat = int(self.getSelectedSatIndex(self.scan_nims.value))
303 tmp_list=[self.satList[int(self.scan_nims.value)][self.scan_satselection[idx_selected_sat].index]]
305 if self.blindscan_hi.value == "hi_low" :
306 tmp_band=["low","high"]
308 tmp_band=[self.blindscan_hi.value]
310 if self.scan_sat.polarization.value == eDVBFrontendParametersSatellite.Polarisation_CircularRight + 1 :
311 tmp_pol=["horizontal","vertical"]
313 tmp_pol=[tab_pol[self.scan_sat.polarization.value]]
315 self.doRun(tmp_list, tmp_pol, tmp_band)
318 if self.checkSettings() == False:
322 tmp_band=["low","high"]
323 tmp_pol=["horizontal","vertical"]
325 for slot in nimmanager.nim_slots:
326 device_name = "/dev/dvb/adapter0/frontend%d" % (slot.slot)
327 if slot.isCompatible("DVB-S") and int(self.scan_nims.value) == slot.slot:
328 for s in self.satList[slot.slot]:
330 self.doRun(tmp_list, tmp_pol, tmp_band)
332 def doRun(self, tmp_list, tmp_pol, tmp_band):
338 self.total_list.append([x,y,z])
339 print "add scan item : ", x, ", ", y, ", ", z
341 self.max_count = len(self.total_list)
342 self.is_runable = True
343 self.running_count = 0
344 self.clockTimer = eTimer()
345 self.clockTimer.callback.append(self.doClock)
346 self.clockTimer.start(1000)
351 if self.running_count >= self.max_count:
352 self.clockTimer.stop()
354 self.clockTimer = None
357 orb = self.total_list[self.running_count][0]
358 pol = self.total_list[self.running_count][1]
359 band = self.total_list[self.running_count][2]
360 self.running_count = self.running_count + 1
361 print "running status-[%d] : [%d][%s][%s]" %(self.running_count, orb[0], pol, band)
362 if self.running_count == self.max_count:
364 self.prepareScanData(orb, pol, band, is_scan)
366 def prepareScanData(self, orb, pol, band, is_scan):
367 self.is_runable = False
368 self.orb_position = orb[0]
369 self.feid = int(self.scan_nims.value)
370 tab_hilow = {"high" : 1, "low" : 0}
372 "horizontal" : eDVBFrontendParametersSatellite.Polarisation_Horizontal,
373 "vertical" : eDVBFrontendParametersSatellite.Polarisation_Vertical,
374 "circular left" : eDVBFrontendParametersSatellite.Polarisation_CircularLeft,
375 "circular right" : eDVBFrontendParametersSatellite.Polarisation_CircularRight
378 returnvalue = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
380 if not self.openFrontend():
381 self.oldref = self.session.nav.getCurrentlyPlayingServiceReference()
382 self.session.nav.stopService()
383 if not self.openFrontend():
384 if self.session.pipshown:
385 self.session.pipshown = False
387 if not self.openFrontend():
389 self.tuner = Tuner(self.frontend)
392 self.scan_sat.frequency.value = 12515
394 self.scan_sat.frequency.value = 11015
395 returnvalue = (self.scan_sat.frequency.value,
401 eDVBFrontendParametersSatellite.System_DVB_S,
405 self.tuner.tune(returnvalue)
407 if self.getNimSocket(self.feid) < 0:
408 print "can't find i2c number!!"
411 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))
412 print "prepared command : [%s]" % (cmd)
413 self.blindscan_container = eConsoleAppContainer()
414 self.blindscan_container.appClosed.append(self.blindscanContainerClose)
415 self.blindscan_container.dataAvail.append(self.blindscanContainerAvail)
416 self.blindscan_container.execute(cmd)
418 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)
420 self.blindscan_session = self.session.openWithCallback(self.blindscanSessionClose, MessageBox, _(tmpstr), MessageBox.TYPE_INFO)
422 self.blindscan_session = self.session.openWithCallback(self.blindscanSessionNone, MessageBox, _(tmpstr), MessageBox.TYPE_INFO)
424 def blindscanContainerClose(self, retval):
425 lines = self.full_data.split('\n')
428 print "cnt :", len(data), ", data :", data
431 parm = eDVBFrontendParametersSatellite()
432 sys = { "DVB-S" : eDVBFrontendParametersSatellite.System_DVB_S,
433 "DVB-S2" : eDVBFrontendParametersSatellite.System_DVB_S2}
434 qam = { "QPSK" : parm.Modulation_QPSK,
435 "8PSK" : parm.Modulation_8PSK}
436 inv = { "INVERSION_OFF" : parm.Inversion_Off,
437 "INVERSION_ON" : parm.Inversion_On,
438 "INVERSION_AUTO" : parm.Inversion_Unknown}
439 fec = { "FEC_AUTO" : parm.FEC_Auto,
440 "FEC_1_2" : parm.FEC_1_2,
441 "FEC_2_3" : parm.FEC_2_3,
442 "FEC_3_4" : parm.FEC_3_4,
443 "FEC_5_6": parm.FEC_5_6,
444 "FEC_7_8" : parm.FEC_7_8,
445 "FEC_8_9" : parm.FEC_8_9,
446 "FEC_3_5" : parm.FEC_3_5,
447 "FEC_9_10" : parm.FEC_9_10,
448 "FEC_NONE" : parm.FEC_None}
449 roll ={ "ROLLOFF_20" : parm.RollOff_alpha_0_20,
450 "ROLLOFF_25" : parm.RollOff_alpha_0_25,
451 "ROLLOFF_35" : parm.RollOff_alpha_0_35}
452 pilot={ "PILOT_ON" : parm.Pilot_On,
453 "PILOT_OFF" : parm.Pilot_Off}
454 pol = { "HORIZONTAL" : parm.Polarisation_Horizontal,
455 "VERTICAL" : parm.Polarisation_Vertical}
456 parm.orbital_position = self.orb_position
457 parm.polarisation = pol[data[1]]
458 parm.frequency = int(data[2])
459 parm.symbol_rate = int(data[3])
460 parm.system = sys[data[4]]
461 parm.inversion = inv[data[5]]
462 parm.pilot = pilot[data[6]]
463 parm.fec = fec[data[7]]
464 parm.modulation = qam[data[8]]
465 parm.rolloff = roll[data[9]]
466 self.tmp_tplist.append(parm)
467 self.blindscan_session.close(True)
469 def blindscanContainerAvail(self, str):
471 #if str.startswith("OK"):
472 self.full_data = self.full_data + str
474 def blindscanSessionNone(self, *val):
476 self.blindscan_container.sendCtrlC()
477 self.blindscan_container = None
486 self.running_count = self.max_count
488 self.is_runable = True
490 def blindscanSessionClose(self, *val):
491 self.blindscanSessionNone(val[0])
493 if self.tmp_tplist != None and self.tmp_tplist != []:
494 for p in self.tmp_tplist:
495 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)
497 self.startScan(self.tmp_tplist, self.feid)
499 msg = "No found transponders!!\nPlease check the satellite connection, or scan other search condition."
501 msg = "Blindscan was canceled by the user."
502 self.session.openWithCallback(self.callbackNone, MessageBox, _(msg), MessageBox.TYPE_INFO, timeout=10)
505 def startScan(self, tlist, feid, networkid = 0):
506 self.scan_session = None
509 if self.scan_clearallservices.value:
510 flags |= eComponentScan.scanRemoveServices
512 flags |= eComponentScan.scanDontRemoveUnscanned
513 if self.scan_onlyfree.value:
514 flags |= eComponentScan.scanOnlyFree
515 self.session.open(ServiceScan, [{"transponders": tlist, "feid": feid, "flags": flags, "networkid": networkid}])
517 def main(session, **kwargs):
518 session.open(Blindscan)
520 def Plugins(**kwargs):
521 return PluginDescriptor(name=_("Blindscan"), description="scan type(DVB-S)", where = PluginDescriptor.WHERE_PLUGINMENU, fnc=main)