code.vuplus.com Git - vuplus_dvbapp/blob - lib/python/Plugins/SystemPlugins/Blindscan/plugin.py

   1 from Plugins.Plugin import PluginDescriptor
   2
   3 from Screens.Screen import Screen
   4 from Screens.ServiceScan import ServiceScan
   5 from Screens.MessageBox import MessageBox
   6 from Screens.DefaultWizard import DefaultWizard
   7
   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
  15
  16 from Tools.HardwareInfo import HardwareInfo
  17 from Tools.Directories import resolveFilename, SCOPE_DEFAULTPARTITIONMOUNTDIR, SCOPE_DEFAULTDIR, SCOPE_DEFAULTPARTITION
  18
  19 from enigma import eTimer, eDVBFrontendParametersSatellite, eComponentScan, eDVBSatelliteEquipmentControl, eDVBFrontendParametersTerrestrial, eDVBFrontendParametersCable, eConsoleAppContainer, eDVBResourceManager, getDesktop
  20
  21 _modelName = file('/proc/stb/info/vumodel').read().strip()
  22 _supportNimType = { 'AVL1208':'', 'AVL6222':'6222_', 'AVL6211':'6211_', 'BCM7356':'bcm7346_'}
  23
  24 class Blindscan(ConfigListScreen, Screen):
  25         skin =  """
  26                 <screen position="center,center" size="560,390" title="Blindscan">
  27                         <ePixmap pixmap="skin_default/buttons/red.png" position="40,10" size="140,40" alphatest="on" />
  28                         <ePixmap pixmap="skin_default/buttons/green.png" position="210,10" size="140,40" alphatest="on" />
  29                         <ePixmap pixmap="skin_default/buttons/blue.png" position="380,10" size="140,40" alphatest="on" />
  30
  31                         <widget source="key_red" render="Label" position="40,10" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#9f1313" foregroundColor="#ffffff" transparent="1"/>
  32                         <widget source="key_green" render="Label" position="210,10" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#1f771f" foregroundColor="#ffffff" transparent="1"/>
  33                         <widget source="key_blue" render="Label" position="380,10" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#18188b" foregroundColor="#ffffff" transparent="1"/>
  34
  35                         <widget name="config" position="5,70" size="550,280" scrollbarMode="showOnDemand" />
  36                         <widget name="introduction" position="0,365" size="560,20" font="Regular;20" halign="center" />
  37                 </screen>
  38                 """
  39
  40         def __init__(self, session):
  41                 Screen.__init__(self, session)
  42
  43                 self.current_play_service = self.session.nav.getCurrentlyPlayingServiceReference()
  44
  45                 # update sat list
  46                 self.satList = []
  47                 for slot in nimmanager.nim_slots:
  48                         if slot.isCompatible("DVB-S"):
  49                                 self.satList.append(nimmanager.getSatListForNim(slot.slot))
  50                         else:
  51                                 self.satList.append(None)
  52
  53                 # make config
  54                 self.createConfig()
  55
  56                 self.list = []
  57                 self.status = ""
  58
  59                 ConfigListScreen.__init__(self, self.list)
  60                 if self.scan_nims.value != None and self.scan_nims.value != "" :
  61                         self["actions"] = ActionMap(["OkCancelActions", "ShortcutActions", "WizardActions", "ColorActions", "SetupActions", ],
  62                         {
  63                                 "red": self.keyCancel,
  64                                 "green": self.keyGo,
  65                                 "blue":self.keyGoAll,
  66                                 "ok": self.keyGo,
  67                                 "cancel": self.keyCancel,
  68                         }, -2)
  69                         self["key_red"] = StaticText(_("Exit"))
  70                         self["key_green"] = StaticText("Scan")
  71                         self["key_blue"] = StaticText("Scan All")
  72                         self["introduction"] = Label(_("Press Green/OK to start the scan"))
  73                         self.createSetup()
  74                 else :
  75                         self["actions"] = ActionMap(["OkCancelActions", "ShortcutActions", "WizardActions", "ColorActions", "SetupActions", ],
  76                         {
  77                                 "red": self.keyCancel,
  78                                 "green": self.keyNone,
  79                                 "blue":self.keyNone,
  80                                 "ok": self.keyNone,
  81                                 "cancel": self.keyCancel,
  82                         }, -2)
  83                         self["key_red"] = StaticText(_("Exit"))
  84                         self["key_green"] = StaticText(" ")
  85                         self["key_blue"] = StaticText(" ")
  86                         self["introduction"] = Label(_("Please setup your tuner configuration."))
  87
  88                 self.i2c_mapping_table = None
  89                 self.nimSockets = self.ScanNimsocket()
  90                 self.makeNimSocket()
  91
  92         def ScanNimsocket(self, filepath = '/proc/bus/nim_sockets'):
  93                 _nimSocket = {}
  94                 fp = file(filepath)
  95
  96                 sNo, sName, sI2C = -1, "", -1
  97                 for line in fp:
  98                         line = line.strip()
  99                         if line.startswith('NIM Socket'):
 100                                 sNo, sName, sI2C = -1, '', -1
 101                                 try:    sNo = line.split()[2][:-1]
 102                                 except: sNo = -1
 103                         elif line.startswith('I2C_Device:'):
 104                                 try:    sI2C = line.split()[1]
 105                                 except: sI2C = -1
 106                         elif line.startswith('Name:'):
 107                                 splitLines = line.split()
 108                                 try:
 109                                         if splitLines[1].startswith('BCM'):
 110                                                 sName = splitLines[1]
 111                                         else:
 112                                                 sName = splitLines[3][4:-1]
 113                                 except: sName = ""
 114                         if sNo >= 0 and sName != "":
 115                                 if sName.startswith('BCM'):
 116                                         sI2C = sNo
 117                                 if sI2C != -1:
 118                                         _nimSocket[sNo] = [sName, sI2C]
 119                                 else:   _nimSocket[sNo] = [sName]
 120                 fp.close()
 121                 print "parsed nimsocket :", _nimSocket
 122                 return _nimSocket
 123
 124         def makeNimSocket(self, nimname=""):
 125                 is_exist_i2c = False
 126                 self.i2c_mapping_table = {0:2, 1:3, 2:1, 3:0}
 127                 if self.nimSockets is not None:
 128                         for XX in self.nimSockets.keys():
 129                                 nimsocket = self.nimSockets[XX]
 130                                 if len(nimsocket) > 1:
 131                                         try:    self.i2c_mapping_table[int(XX)] = int(nimsocket[1])
 132                                         except: continue
 133                                         is_exist_i2c = True
 134                 print "i2c_mapping_table :", self.i2c_mapping_table, ", is_exist_i2c :", is_exist_i2c
 135                 if is_exist_i2c: return
 136
 137                 if nimname == "AVL6222":
 138                         model = _modelName #file('/proc/stb/info/vumodel').read().strip()
 139                         if model == "uno":
 140                                 self.i2c_mapping_table = {0:3, 1:3, 2:1, 3:0}
 141                         elif model == "duo2":
 142                                 nimdata = self.nimSockets['0']
 143                                 try:
 144                                         if nimdata[0] == "AVL6222":
 145                                                 self.i2c_mapping_table = {0:2, 1:2, 2:4, 3:4}
 146                                         else:   self.i2c_mapping_table = {0:2, 1:4, 2:4, 3:0}
 147                                 except: self.i2c_mapping_table = {0:2, 1:4, 2:4, 3:0}
 148                         else:   self.i2c_mapping_table = {0:2, 1:4, 2:0, 3:0}
 149                 else:   self.i2c_mapping_table = {0:2, 1:3, 2:1, 3:0}
 150
 151         def getNimSocket(self, slot_number):
 152                 return self.i2c_mapping_table.get(slot_number, -1)
 153
 154         def keyNone(self):
 155                 None
 156         def callbackNone(self, *retval):
 157                 None
 158
 159         def openFrontend(self):
 160                 res_mgr = eDVBResourceManager.getInstance()
 161                 if res_mgr:
 162                         self.raw_channel = res_mgr.allocateRawChannel(self.feid)
 163                         if self.raw_channel:
 164                                 self.frontend = self.raw_channel.getFrontend()
 165                                 if self.frontend:
 166                                         return True
 167                                 else:
 168                                         print "getFrontend failed"
 169                         else:
 170                                 print "getRawChannel failed"
 171                 else:
 172                         print "getResourceManager instance failed"
 173                 return False
 174
 175         def createConfig(self):
 176                 self.feinfo = None
 177                 frontendData = None
 178                 defaultSat = {
 179                         "orbpos": 192,
 180                         "system": eDVBFrontendParametersSatellite.System_DVB_S,
 181                         "frequency": 11836,
 182                         "inversion": eDVBFrontendParametersSatellite.Inversion_Unknown,
 183                         "symbolrate": 27500,
 184                         "polarization": eDVBFrontendParametersSatellite.Polarisation_Horizontal,
 185                         "fec": eDVBFrontendParametersSatellite.FEC_Auto,
 186                         "fec_s2": eDVBFrontendParametersSatellite.FEC_9_10,
 187                         "modulation": eDVBFrontendParametersSatellite.Modulation_QPSK
 188                 }
 189
 190                 self.service = self.session.nav.getCurrentService()
 191                 if self.service is not None:
 192                         self.feinfo = self.service.frontendInfo()
 193                         frontendData = self.feinfo and self.feinfo.getAll(True)
 194                 if frontendData is not None:
 195                         ttype = frontendData.get("tuner_type", "UNKNOWN")
 196                         if ttype == "DVB-S":
 197                                 defaultSat["system"] = frontendData.get("system", eDVBFrontendParametersSatellite.System_DVB_S)
 198                                 defaultSat["frequency"] = frontendData.get("frequency", 0) / 1000
 199                                 defaultSat["inversion"] = frontendData.get("inversion", eDVBFrontendParametersSatellite.Inversion_Unknown)
 200                                 defaultSat["symbolrate"] = frontendData.get("symbol_rate", 0) / 1000
 201                                 defaultSat["polarization"] = frontendData.get("polarization", eDVBFrontendParametersSatellite.Polarisation_Horizontal)
 202                                 if defaultSat["system"] == eDVBFrontendParametersSatellite.System_DVB_S2:
 203                                         defaultSat["fec_s2"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto)
 204                                         defaultSat["rolloff"] = frontendData.get("rolloff", eDVBFrontendParametersSatellite.RollOff_alpha_0_35)
 205                                         defaultSat["pilot"] = frontendData.get("pilot", eDVBFrontendParametersSatellite.Pilot_Unknown)
 206                                 else:
 207                                         defaultSat["fec"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto)
 208                                 defaultSat["modulation"] = frontendData.get("modulation", eDVBFrontendParametersSatellite.Modulation_QPSK)
 209                                 defaultSat["orbpos"] = frontendData.get("orbital_position", 0)
 210                 del self.feinfo
 211                 del self.service
 212                 del frontendData
 213
 214                 self.scan_sat = ConfigSubsection()
 215                 self.scan_networkScan = ConfigYesNo(default = False)
 216
 217                 # blindscan add
 218                 self.blindscan_hi = ConfigSelection(default = "hi_low", choices = [("low", _("low")), ("high", _("high")), ("hi_low", _("hi_low"))])
 219
 220                 #ConfigYesNo(default = True)
 221                 self.blindscan_start_frequency = ConfigInteger(default = 950*1000000)
 222                 self.blindscan_stop_frequency = ConfigInteger(default = 2150*1000000)
 223                 self.blindscan_start_symbol = ConfigInteger(default = 2*1000000)
 224                 self.blindscan_stop_symbol = ConfigInteger(default = 45*1000000)
 225                 self.scan_clearallservices = ConfigYesNo(default = False)
 226                 self.scan_onlyfree = ConfigYesNo(default = False)
 227
 228                 # collect all nims which are *not* set to "nothing"
 229                 nim_list = []
 230                 for n in nimmanager.nim_slots:
 231                         if n.config_mode == "nothing":
 232                                 continue
 233                         if n.config_mode == "advanced" and len(nimmanager.getSatListForNim(n.slot)) < 1:
 234                                 continue
 235                         if n.config_mode in ("loopthrough", "satposdepends"):
 236                                 root_id = nimmanager.sec.getRoot(n.slot_id, int(n.config.connectedTo.value))
 237                                 if n.type == nimmanager.nim_slots[root_id].type: # check if connected from a DVB-S to DVB-S2 Nim or vice versa
 238                                         continue
 239                         if n.isCompatible("DVB-S"):
 240                                 nim_list.append((str(n.slot), n.friendly_full_description))
 241                 self.scan_nims = ConfigSelection(choices = nim_list)
 242
 243                 # sat
 244                 self.scan_sat.frequency = ConfigInteger(default = defaultSat["frequency"], limits = (1, 99999))
 245                 #self.scan_sat.polarization = ConfigSelection(default = defaultSat["polarization"], choices = [
 246                 self.scan_sat.polarization = ConfigSelection(default = eDVBFrontendParametersSatellite.Polarisation_CircularRight + 1, choices = [
 247                         (eDVBFrontendParametersSatellite.Polarisation_CircularRight + 1, _("horizontal_vertical")),
 248                         (eDVBFrontendParametersSatellite.Polarisation_Horizontal, _("horizontal")),
 249                         (eDVBFrontendParametersSatellite.Polarisation_Vertical, _("vertical")),
 250                         (eDVBFrontendParametersSatellite.Polarisation_CircularLeft, _("circular left")),
 251                         (eDVBFrontendParametersSatellite.Polarisation_CircularRight, _("circular right"))])
 252                 self.scan_scansat = {}
 253                 for sat in nimmanager.satList:
 254                         self.scan_scansat[sat[0]] = ConfigYesNo(default = False)
 255
 256                 self.scan_satselection = []
 257                 for slot in nimmanager.nim_slots:
 258                         if slot.isCompatible("DVB-S"):
 259                                 self.scan_satselection.append(getConfigSatlist(defaultSat["orbpos"], self.satList[slot.slot]))
 260                 return True
 261
 262         def getSelectedSatIndex(self, v):
 263                 index    = 0
 264                 none_cnt = 0
 265                 for n in self.satList:
 266                         if self.satList[index] == None:
 267                                 none_cnt = none_cnt + 1
 268                         if index == int(v):
 269                                 return (index-none_cnt)
 270                         index = index + 1
 271                 return -1
 272
 273         def createSetup(self):
 274                 self.list = []
 275                 self.multiscanlist = []
 276                 index_to_scan = int(self.scan_nims.value)
 277                 print "ID: ", index_to_scan
 278
 279                 self.tunerEntry = getConfigListEntry(_("Tuner"), self.scan_nims)
 280                 self.list.append(self.tunerEntry)
 281
 282                 if self.scan_nims == [ ]:
 283                         return
 284
 285                 self.systemEntry = None
 286                 self.modulationEntry = None
 287                 nim = nimmanager.nim_slots[index_to_scan]
 288
 289                 self.scan_networkScan.value = False
 290                 if nim.isCompatible("DVB-S") :
 291                         self.list.append(getConfigListEntry(_('Satellite'), self.scan_satselection[self.getSelectedSatIndex(index_to_scan)]))
 292                         self.list.append(getConfigListEntry(_('Scan start frequency'), self.blindscan_start_frequency))
 293                         self.list.append(getConfigListEntry(_('Scan stop frequency'), self.blindscan_stop_frequency))
 294                         self.list.append(getConfigListEntry(_("Polarity"), self.scan_sat.polarization))
 295                         self.list.append(getConfigListEntry(_("Scan band"), self.blindscan_hi))
 296                         self.list.append(getConfigListEntry(_('Scan start symbolrate'), self.blindscan_start_symbol))
 297                         self.list.append(getConfigListEntry(_('Scan stop symbolrate'), self.blindscan_stop_symbol))
 298                         self.list.append(getConfigListEntry(_("Clear before scan"), self.scan_clearallservices))
 299                         self.list.append(getConfigListEntry(_("Only Free scan"), self.scan_onlyfree))
 300                         self["config"].list = self.list
 301                         self["config"].l.setList(self.list)
 302
 303         def newConfig(self):
 304                 cur = self["config"].getCurrent()
 305                 print "cur is", cur
 306                 if cur == self.tunerEntry or \
 307                         cur == self.systemEntry or \
 308                         (self.modulationEntry and self.systemEntry[1].value == eDVBFrontendParametersSatellite.System_DVB_S2 and cur == self.modulationEntry):
 309                         self.createSetup()
 310
 311         def checkSettings(self):
 312                 if self.blindscan_start_frequency.value < 950*1000000 or self.blindscan_start_frequency.value > 2150*1000000 :
 313                         self.session.open(MessageBox, _("Please check again.\nStart frequency must be between 950 and 2150."), MessageBox.TYPE_ERROR)
 314                         return False
 315                 if self.blindscan_stop_frequency.value < 950*1000000 or self.blindscan_stop_frequency.value > 2150*1000000 :
 316                         self.session.open(MessageBox, _("Please check again.\nStop frequency must be between 950 and 2150."), MessageBox.TYPE_ERROR)
 317                         return False
 318                 if self.blindscan_start_frequency.value > self.blindscan_stop_frequency.value :
 319                         self.session.open(MessageBox, _("Please check again.\nFrequency : start value is larger than stop value."), MessageBox.TYPE_ERROR)
 320                         return False
 321                 if self.blindscan_start_symbol.value < 2*1000000 or self.blindscan_start_symbol.value > 45*1000000 :
 322                         self.session.open(MessageBox, _("Please check again.\nStart symbolrate must be between 2MHz and 45MHz."), MessageBox.TYPE_ERROR)
 323                         return False
 324                 if self.blindscan_stop_symbol.value < 2*1000000 or self.blindscan_stop_symbol.value > 45*1000000 :
 325                         self.session.open(MessageBox, _("Please check again.\nStop symbolrate must be between 2MHz and 45MHz."), MessageBox.TYPE_ERROR)
 326                         return False
 327                 if self.blindscan_start_symbol.value > self.blindscan_stop_symbol.value :
 328                         self.session.open(MessageBox, _("Please check again.\nSymbolrate : start value is larger than stop value."), MessageBox.TYPE_ERROR)
 329                         return False
 330                 return True
 331
 332         def keyLeft(self):
 333                 ConfigListScreen.keyLeft(self)
 334                 self.newConfig()
 335
 336         def keyRight(self):
 337                 ConfigListScreen.keyRight(self)
 338                 self.newConfig()
 339
 340         def keyCancel(self):
 341                 self.session.nav.playService(self.current_play_service)
 342                 for x in self["config"].list:
 343                         x[1].cancel()
 344                 self.close()
 345
 346         def keyGo(self):
 347                 if self.checkSettings() == False:
 348                         return
 349
 350                 tab_pol = {
 351                         eDVBFrontendParametersSatellite.Polarisation_Horizontal : "horizontal",
 352                         eDVBFrontendParametersSatellite.Polarisation_Vertical : "vertical",
 353                         eDVBFrontendParametersSatellite.Polarisation_CircularLeft : "circular left",
 354                         eDVBFrontendParametersSatellite.Polarisation_CircularRight : "circular right",
 355                         eDVBFrontendParametersSatellite.Polarisation_CircularRight + 1 : "horizontal_vertical"
 356                 }
 357
 358                 self.tmp_tplist=[]
 359                 tmp_pol = []
 360                 tmp_band = []
 361                 idx_selected_sat = int(self.getSelectedSatIndex(self.scan_nims.value))
 362                 tmp_list=[self.satList[int(self.scan_nims.value)][self.scan_satselection[idx_selected_sat].index]]
 363
 364                 if self.blindscan_hi.value == "hi_low" :
 365                         tmp_band=["low","high"]
 366                 else:
 367                         tmp_band=[self.blindscan_hi.value]
 368
 369                 if self.scan_sat.polarization.value ==  eDVBFrontendParametersSatellite.Polarisation_CircularRight + 1 :
 370                         tmp_pol=["horizontal","vertical"]
 371                 else:
 372                         tmp_pol=[tab_pol[self.scan_sat.polarization.value]]
 373
 374                 self.doRun(tmp_list, tmp_pol, tmp_band)
 375
 376         def keyGoAll(self):
 377                 if self.checkSettings() == False:
 378                         return
 379                 self.tmp_tplist=[]
 380                 tmp_list=[]
 381                 tmp_band=["low","high"]
 382                 tmp_pol=["horizontal","vertical"]
 383
 384                 for slot in nimmanager.nim_slots:
 385                         device_name = "/dev/dvb/adapter0/frontend%d" % (slot.slot)
 386                         if slot.isCompatible("DVB-S") and int(self.scan_nims.value) == slot.slot:
 387                                 for s in self.satList[slot.slot]:
 388                                         tmp_list.append(s)
 389                 self.doRun(tmp_list, tmp_pol, tmp_band)
 390
 391         def doRun(self, tmp_list, tmp_pol, tmp_band):
 392                 def GetCommand(nimIdx):
 393                         _nimSocket = self.nimSockets
 394                         try:
 395                                 sName = _nimSocket[str(nimIdx)][0]
 396                                 sType = _supportNimType[sName]
 397                                 return "vuplus_%(TYPE)sblindscan"%{'TYPE':sType}, sName
 398                         except: pass
 399                         return "vuplus_blindscan", ""
 400                 self.binName,nimName =  GetCommand(self.scan_nims.value)
 401
 402                 self.makeNimSocket(nimName)
 403                 if self.binName is None:
 404                         self.session.open(MessageBox, "Blindscan is not supported in " + nimName + " tuner.", MessageBox.TYPE_ERROR)
 405                         print nimName + " is not support blindscan."
 406                         return
 407
 408                 self.full_data = ""
 409                 self.total_list=[]
 410                 for x in tmp_list:
 411                         for y in tmp_pol:
 412                                 for z in tmp_band:
 413                                         self.total_list.append([x,y,z])
 414                                         print "add scan item : ", x, ", ", y, ", ", z
 415
 416                 self.max_count = len(self.total_list)
 417                 self.is_runable = True
 418                 self.running_count = 0
 419                 self.clockTimer = eTimer()
 420                 self.clockTimer.callback.append(self.doClock)
 421                 self.clockTimer.start(1000)
 422
 423         def doClock(self):
 424                 is_scan = False
 425                 if self.is_runable :
 426                         if self.running_count >= self.max_count:
 427                                 self.clockTimer.stop()
 428                                 del self.clockTimer
 429                                 self.clockTimer = None
 430                                 print "Done"
 431                                 return
 432                         orb = self.total_list[self.running_count][0]
 433                         pol = self.total_list[self.running_count][1]
 434                         band = self.total_list[self.running_count][2]
 435                         self.running_count = self.running_count + 1
 436                         print "running status-[%d] : [%d][%s][%s]" %(self.running_count, orb[0], pol, band)
 437                         if self.running_count == self.max_count:
 438                                 is_scan = True
 439                         self.prepareScanData(orb, pol, band, is_scan)
 440
 441         def prepareScanData(self, orb, pol, band, is_scan):
 442                 self.is_runable = False
 443                 self.orb_position = orb[0]
 444                 self.feid = int(self.scan_nims.value)
 445                 tab_hilow = {"high" : 1, "low" : 0}
 446                 tab_pol = {
 447                         "horizontal" : eDVBFrontendParametersSatellite.Polarisation_Horizontal,
 448                         "vertical" : eDVBFrontendParametersSatellite.Polarisation_Vertical,
 449                         "circular left" : eDVBFrontendParametersSatellite.Polarisation_CircularLeft,
 450                         "circular right" : eDVBFrontendParametersSatellite.Polarisation_CircularRight
 451                 }
 452
 453                 returnvalue = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
 454
 455                 if not self.openFrontend():
 456                         self.oldref = self.session.nav.getCurrentlyPlayingServiceReference()
 457                         self.session.nav.stopService()
 458                         if not self.openFrontend():
 459                                 if self.session.pipshown:
 460                                         self.session.pipshown = False
 461                                         del self.session.pip
 462                                         if not self.openFrontend():
 463                                                 self.frontend = None
 464                 self.tuner = Tuner(self.frontend)
 465
 466                 if tab_hilow[band]:
 467                         self.scan_sat.frequency.value = 12515
 468                 else:
 469                         self.scan_sat.frequency.value = 11015
 470                 returnvalue = (self.scan_sat.frequency.value,
 471                                          0,
 472                                          tab_pol[pol],
 473                                          0,
 474                                          0,
 475                                          orb[0],
 476                                          eDVBFrontendParametersSatellite.System_DVB_S,
 477                                          0,
 478                                          0,
 479                                          0)
 480                 self.tuner.tune(returnvalue)
 481
 482                 if self.getNimSocket(self.feid) < 0:
 483                         print "can't find i2c number!!"
 484                         return
 485                 try:
 486                         cmd = "%s %d %d %d %d %d %d %d %d" % (self.binName, 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))
 487                 except: return
 488                 print "prepared command : [%s]" % (cmd)
 489                 self.blindscan_container = eConsoleAppContainer()
 490                 self.blindscan_container.appClosed.append(self.blindscanContainerClose)
 491                 self.blindscan_container.dataAvail.append(self.blindscanContainerAvail)
 492                 self.blindscan_container.execute(cmd)
 493
 494                 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)
 495                 if is_scan :
 496                         self.blindscan_session = self.session.openWithCallback(self.blindscanSessionClose, MessageBox, _(tmpstr), MessageBox.TYPE_INFO)
 497                 else:
 498                         self.blindscan_session = self.session.openWithCallback(self.blindscanSessionNone, MessageBox, _(tmpstr), MessageBox.TYPE_INFO)
 499
 500         def blindscanContainerClose(self, retval):
 501                 lines = self.full_data.split('\n')
 502                 for line in lines:
 503                         data = line.split()
 504                         print "cnt :", len(data), ", data :", data
 505                         if len(data) >= 10:
 506                                 if data[0] == 'OK':
 507                                         parm = eDVBFrontendParametersSatellite()
 508                                         sys = { "DVB-S" : eDVBFrontendParametersSatellite.System_DVB_S,
 509                                                 "DVB-S2" : eDVBFrontendParametersSatellite.System_DVB_S2}
 510                                         qam = { "QPSK" : parm.Modulation_QPSK,
 511                                                 "8PSK" : parm.Modulation_8PSK}
 512                                         inv = { "INVERSION_OFF" : parm.Inversion_Off,
 513                                                 "INVERSION_ON" : parm.Inversion_On,
 514                                                 "INVERSION_AUTO" : parm.Inversion_Unknown}
 515                                         fec = { "FEC_AUTO" : parm.FEC_Auto,
 516                                                 "FEC_1_2" : parm.FEC_1_2,
 517                                                 "FEC_2_3" : parm.FEC_2_3,
 518                                                 "FEC_3_4" : parm.FEC_3_4,
 519                                                 "FEC_5_6": parm.FEC_5_6,
 520                                                 "FEC_7_8" : parm.FEC_7_8,
 521                                                 "FEC_8_9" : parm.FEC_8_9,
 522                                                 "FEC_3_5" : parm.FEC_3_5,
 523                                                 "FEC_9_10" : parm.FEC_9_10,
 524                                                 "FEC_NONE" : parm.FEC_None}
 525                                         roll ={ "ROLLOFF_20" : parm.RollOff_alpha_0_20,
 526                                                 "ROLLOFF_25" : parm.RollOff_alpha_0_25,
 527                                                 "ROLLOFF_35" : parm.RollOff_alpha_0_35}
 528                                         pilot={ "PILOT_ON" : parm.Pilot_On,
 529                                                 "PILOT_OFF" : parm.Pilot_Off,
 530                                                 "PILOT_AUTO" : parm.Pilot_Unknown}
 531                                         pol = { "HORIZONTAL" : parm.Polarisation_Horizontal,
 532                                                 "VERTICAL" : parm.Polarisation_Vertical}
 533                                         try :
 534                                                 parm.orbital_position = self.orb_position
 535                                                 parm.polarisation = pol[data[1]]
 536                                                 parm.frequency = int(data[2])
 537                                                 parm.symbol_rate = int(data[3])
 538                                                 parm.system = sys[data[4]]
 539                                                 parm.inversion = inv[data[5]]
 540                                                 parm.pilot = pilot[data[6]]
 541                                                 parm.fec = fec[data[7]]
 542                                                 parm.modulation = qam[data[8]]
 543                                                 parm.rolloff = roll[data[9]]
 544                                                 self.tmp_tplist.append(parm)
 545                                         except: pass
 546                 self.blindscan_session.close(True)
 547
 548         def blindscanContainerAvail(self, str):
 549                 print str
 550                 #if str.startswith("OK"):
 551                 self.full_data = self.full_data + str
 552
 553         def blindscanSessionNone(self, *val):
 554                 import time
 555                 self.blindscan_container.sendCtrlC()
 556                 self.blindscan_container = None
 557                 time.sleep(2)
 558
 559                 if self.frontend:
 560                         self.frontend = None
 561                         del self.raw_channel
 562
 563                 if val[0] == False:
 564                         self.tmp_tplist = []
 565                         self.running_count = self.max_count
 566
 567                 self.is_runable = True
 568
 569         def blindscanSessionClose(self, *val):
 570                 self.blindscanSessionNone(val[0])
 571
 572                 if self.tmp_tplist != None and self.tmp_tplist != []:
 573                         for p in self.tmp_tplist:
 574                                 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)
 575
 576                         self.startScan(self.tmp_tplist, self.feid)
 577                 else:
 578                         msg = "No found transponders!!\nPlease check the satellite connection, or scan other search condition."
 579                         if val[0] == False:
 580                                 msg = "Blindscan was canceled by the user."
 581                         self.session.openWithCallback(self.callbackNone, MessageBox, _(msg), MessageBox.TYPE_INFO, timeout=10)
 582                         self.tmp_tplist = []
 583
 584         def startScan(self, tlist, feid, networkid = 0):
 585                 self.scan_session = None
 586
 587                 flags = 0
 588                 if self.scan_clearallservices.value:
 589                         flags |= eComponentScan.scanRemoveServices
 590                 else:
 591                         flags |= eComponentScan.scanDontRemoveUnscanned
 592                 if self.scan_onlyfree.value:
 593                         flags |= eComponentScan.scanOnlyFree
 594                 self.session.open(ServiceScan, [{"transponders": tlist, "feid": feid, "flags": flags, "networkid": networkid}])
 595
 596 def main(session, **kwargs):
 597         session.open(Blindscan)
 598
 599 def Plugins(**kwargs):
 600         return PluginDescriptor(name=_("Blindscan"), description="scan type(DVB-S)", where = PluginDescriptor.WHERE_PLUGINMENU, fnc=main)
 601