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
  20
  21 class Blindscan(ConfigListScreen, Screen):
  22         skin="""
  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" />
  27
  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"/>
  31
  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" />
  34                 </screen>
  35                 """
  36         def __init__(self, session):
  37                 Screen.__init__(self, session)
  38
  39                 self.current_play_service = self.session.nav.getCurrentlyPlayingServiceReference()
  40
  41                 # update sat list
  42                 self.satList = []
  43                 for slot in nimmanager.nim_slots:
  44                         if slot.isCompatible("DVB-S"):
  45                                 self.satList.append(nimmanager.getSatListForNim(slot.slot))
  46                         else:
  47                                 self.satList.append(None)
  48
  49                 # make config
  50                 self.createConfig()
  51
  52                 self.list = []
  53                 self.status = ""
  54
  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", ],
  58                         {
  59                                 "red": self.keyCancel,
  60                                 "green": self.keyGo,
  61                                 "blue":self.keyGoAll,
  62                                 "ok": self.keyGo,
  63                                 "cancel": self.keyCancel,
  64                         }, -2)
  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"))
  69                         self.createSetup()
  70                 else :
  71                         self["actions"] = ActionMap(["OkCancelActions", "ShortcutActions", "WizardActions", "ColorActions", "SetupActions", ],
  72                         {
  73                                 "red": self.keyCancel,
  74                                 "green": self.keyNone,
  75                                 "blue":self.keyNone,
  76                                 "ok": self.keyNone,
  77                                 "cancel": self.keyCancel,
  78                         }, -2)
  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."))
  83
  84                 self.i2c_mapping_table = None
  85                 self.makeNimSocket()
  86
  87         def makeNimSocket(self):
  88                 self.i2c_mapping_table = {0:2, 1:3, 2:1, 3:0}
  89
  90         def getNimSocket(self, slot_number):
  91                 if slot_number < 0 or slot_number > 3:
  92                         return -1
  93                 return self.i2c_mapping_table[slot_number]
  94
  95         def keyNone(self):
  96                 None
  97         def callbackNone(self, *retval):
  98                 None
  99
 100         def openFrontend(self):
 101                 res_mgr = eDVBResourceManager.getInstance()
 102                 if res_mgr:
 103                         self.raw_channel = res_mgr.allocateRawChannel(self.feid)
 104                         if self.raw_channel:
 105                                 self.frontend = self.raw_channel.getFrontend()
 106                                 if self.frontend:
 107                                         return True
 108                                 else:
 109                                         print "getFrontend failed"
 110                         else:
 111                                 print "getRawChannel failed"
 112                 else:
 113                         print "getResourceManager instance failed"
 114                 return False
 115
 116         def createConfig(self):
 117                 self.feinfo = None
 118                 frontendData = None
 119                 defaultSat = {
 120                         "orbpos": 192,
 121                         "system": eDVBFrontendParametersSatellite.System_DVB_S,
 122                         "frequency": 11836,
 123                         "inversion": eDVBFrontendParametersSatellite.Inversion_Unknown,
 124                         "symbolrate": 27500,
 125                         "polarization": eDVBFrontendParametersSatellite.Polarisation_Horizontal,
 126                         "fec": eDVBFrontendParametersSatellite.FEC_Auto,
 127                         "fec_s2": eDVBFrontendParametersSatellite.FEC_9_10,
 128                         "modulation": eDVBFrontendParametersSatellite.Modulation_QPSK
 129                 }
 130
 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")
 137                         if ttype == "DVB-S":
 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)
 147                                 else:
 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)
 151                 del self.feinfo
 152                 del self.service
 153                 del frontendData
 154
 155                 self.scan_sat = ConfigSubsection()
 156                 self.scan_networkScan = ConfigYesNo(default = False)
 157
 158                 # blindscan add
 159                 self.blindscan_hi = ConfigSelection(default = "hi_low", choices = [("low", _("low")), ("high", _("high")), ("hi_low", _("hi_low"))])
 160
 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)
 168
 169                 # collect all nims which are *not* set to "nothing"
 170                 nim_list = []
 171                 for n in nimmanager.nim_slots:
 172                         if n.config_mode == "nothing":
 173                                 continue
 174                         if n.config_mode == "advanced" and len(nimmanager.getSatListForNim(n.slot)) < 1:
 175                                 continue
 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
 179                                         continue
 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)
 183
 184                 # sat
 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)
 196
 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]))
 201                 return True
 202
 203         def getSelectedSatIndex(self, v):
 204                 index    = 0
 205                 none_cnt = 0
 206                 for n in self.satList:
 207                         if self.satList[index] == None:
 208                                 none_cnt = none_cnt + 1
 209                         if index == int(v):
 210                                 return (index-none_cnt)
 211                         index = index + 1
 212                 return -1
 213
 214         def createSetup(self):
 215                 self.list = []
 216                 self.multiscanlist = []
 217                 index_to_scan = int(self.scan_nims.value)
 218                 print "ID: ", index_to_scan
 219
 220                 self.tunerEntry = getConfigListEntry(_("Tuner"), self.scan_nims)
 221                 self.list.append(self.tunerEntry)
 222
 223                 if self.scan_nims == [ ]:
 224                         return
 225
 226                 self.systemEntry = None
 227                 self.modulationEntry = None
 228                 nim = nimmanager.nim_slots[index_to_scan]
 229
 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)
 243
 244         def newConfig(self):
 245                 cur = self["config"].getCurrent()
 246                 print "cur is", cur
 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):
 250                         self.createSetup()
 251
 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)
 255                         return False
 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)
 258                         return False
 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)
 261                         return False
 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)
 264                         return False
 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)
 267                         return False
 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)
 270                         return False
 271                 return True
 272
 273         def keyLeft(self):
 274                 ConfigListScreen.keyLeft(self)
 275                 self.newConfig()
 276
 277         def keyRight(self):
 278                 ConfigListScreen.keyRight(self)
 279                 self.newConfig()
 280
 281         def keyCancel(self):
 282                 self.session.nav.playService(self.current_play_service)
 283                 for x in self["config"].list:
 284                         x[1].cancel()
 285                 self.close()
 286
 287         def keyGo(self):
 288                 if self.checkSettings() == False:
 289                         return
 290
 291                 tab_pol = {
 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"
 297                 }
 298
 299                 self.tmp_tplist=[]
 300                 tmp_pol = []
 301                 tmp_band = []
 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]]
 304
 305                 if self.blindscan_hi.value == "hi_low" :
 306                         tmp_band=["low","high"]
 307                 else:
 308                         tmp_band=[self.blindscan_hi.value]
 309
 310                 if self.scan_sat.polarization.value ==  eDVBFrontendParametersSatellite.Polarisation_CircularRight + 1 :
 311                         tmp_pol=["horizontal","vertical"]
 312                 else:
 313                         tmp_pol=[tab_pol[self.scan_sat.polarization.value]]
 314
 315                 self.doRun(tmp_list, tmp_pol, tmp_band)
 316
 317         def keyGoAll(self):
 318                 if self.checkSettings() == False:
 319                         return
 320                 self.tmp_tplist=[]
 321                 tmp_list=[]
 322                 tmp_band=["low","high"]
 323                 tmp_pol=["horizontal","vertical"]
 324
 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]:
 329                                         tmp_list.append(s)
 330                 self.doRun(tmp_list, tmp_pol, tmp_band)
 331
 332         def doRun(self, tmp_list, tmp_pol, tmp_band):
 333                 self.full_data = ""
 334                 self.total_list=[]
 335                 for x in tmp_list:
 336                         for y in tmp_pol:
 337                                 for z in tmp_band:
 338                                         self.total_list.append([x,y,z])
 339                                         print "add scan item : ", x, ", ", y, ", ", z
 340
 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)
 347
 348         def doClock(self):
 349                 is_scan = False
 350                 if self.is_runable :
 351                         if self.running_count >= self.max_count:
 352                                 self.clockTimer.stop()
 353                                 del self.clockTimer
 354                                 self.clockTimer = None
 355                                 print "Done"
 356                                 return
 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:
 363                                 is_scan = True
 364                         self.prepareScanData(orb, pol, band, is_scan)
 365
 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}
 371                 tab_pol = {
 372                         "horizontal" : eDVBFrontendParametersSatellite.Polarisation_Horizontal,
 373                         "vertical" : eDVBFrontendParametersSatellite.Polarisation_Vertical,
 374                         "circular left" : eDVBFrontendParametersSatellite.Polarisation_CircularLeft,
 375                         "circular right" : eDVBFrontendParametersSatellite.Polarisation_CircularRight
 376                 }
 377
 378                 returnvalue = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
 379
 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
 386                                         del self.session.pip
 387                                         if not self.openFrontend():
 388                                                 self.frontend = None
 389                 self.tuner = Tuner(self.frontend)
 390
 391                 if tab_hilow[band]:
 392                         self.scan_sat.frequency.value = 12515
 393                 else:
 394                         self.scan_sat.frequency.value = 11015
 395                 returnvalue = (self.scan_sat.frequency.value,
 396                                          0,
 397                                          tab_pol[pol],
 398                                          0,
 399                                          0,
 400                                          orb[0],
 401                                          eDVBFrontendParametersSatellite.System_DVB_S,
 402                                          0,
 403                                          0,
 404                                          0)
 405                 self.tuner.tune(returnvalue)
 406
 407                 if self.getNimSocket(self.feid) < 0:
 408                         print "can't find i2c number!!"
 409                         return
 410
 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)
 417
 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)
 419                 if is_scan :
 420                         self.blindscan_session = self.session.openWithCallback(self.blindscanSessionClose, MessageBox, _(tmpstr), MessageBox.TYPE_INFO)
 421                 else:
 422                         self.blindscan_session = self.session.openWithCallback(self.blindscanSessionNone, MessageBox, _(tmpstr), MessageBox.TYPE_INFO)
 423
 424         def blindscanContainerClose(self, retval):
 425                 lines = self.full_data.split('\n')
 426                 for line in lines:
 427                         data = line.split()
 428                         print "cnt :", len(data), ", data :", data
 429                         if len(data) >= 10:
 430                                 if data[0] == 'OK':
 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)
 468
 469         def blindscanContainerAvail(self, str):
 470                 print str
 471                 #if str.startswith("OK"):
 472                 self.full_data = self.full_data + str
 473
 474         def blindscanSessionNone(self, *val):
 475                 import time
 476                 self.blindscan_container.sendCtrlC()
 477                 self.blindscan_container = None
 478                 time.sleep(2)
 479
 480                 if self.frontend:
 481                         self.frontend = None
 482                         del self.raw_channel
 483
 484                 if val[0] == False:
 485                         self.tmp_tplist = []
 486                         self.running_count = self.max_count
 487
 488                 self.is_runable = True
 489
 490         def blindscanSessionClose(self, *val):
 491                 self.blindscanSessionNone(val[0])
 492
 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)
 496
 497                         self.startScan(self.tmp_tplist, self.feid)
 498                 else:
 499                         msg = "No found transponders!!\nPlease check the satellite connection, or scan other search condition."
 500                         if val[0] == False:
 501                                 msg = "Blindscan was canceled by the user."
 502                         self.session.openWithCallback(self.callbackNone, MessageBox, _(msg), MessageBox.TYPE_INFO, timeout=10)
 503                         self.tmp_tplist = []
 504
 505         def startScan(self, tlist, feid, networkid = 0):
 506                 self.scan_session = None
 507
 508                 flags = 0
 509                 if self.scan_clearallservices.value:
 510                         flags |= eComponentScan.scanRemoveServices
 511                 else:
 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}])
 516
 517 def main(session, **kwargs):
 518         session.open(Blindscan)
 519
 520 def Plugins(**kwargs):
 521         return PluginDescriptor(name=_("Blindscan"), description="scan type(DVB-S)", where = PluginDescriptor.WHERE_PLUGINMENU, fnc=main)
 522