Support duo4k.

[vuplus_dvbapp] / lib / python / Screens / ScanSetup.py

diff --git a/lib/python/Screens/ScanSetup.py b/lib/python/Screens/ScanSetup.py
index 08ce21e..7465fde 100644 (file)
--- a/lib/python/Screens/ScanSetup.py
+++ b/lib/python/Screens/ScanSetup.py
@@ -7,6 +7,7 @@ from Components.ActionMap import NumberActionMap, ActionMap
 from Components.ConfigList import ConfigListScreen
 from Components.NimManager import nimmanager, getConfigSatlist
 from Components.Label import Label
 from Components.ConfigList import ConfigListScreen
 from Components.NimManager import nimmanager, getConfigSatlist
 from Components.Label import Label

+from Components.SystemInfo import SystemInfo

 from Tools.Directories import resolveFilename, SCOPE_DEFAULTPARTITIONMOUNTDIR, SCOPE_DEFAULTDIR, SCOPE_DEFAULTPARTITION
 from Tools.HardwareInfo import HardwareInfo
 from Screens.MessageBox import MessageBox
 from Tools.Directories import resolveFilename, SCOPE_DEFAULTPARTITIONMOUNTDIR, SCOPE_DEFAULTDIR, SCOPE_DEFAULTPARTITION
 from Tools.HardwareInfo import HardwareInfo
 from Screens.MessageBox import MessageBox


@@ -48,6 +49,9 @@ def getInitialTransponderList(tlist, pos):
                        parm.modulation = x[6]
                        parm.rolloff = x[8]
                        parm.pilot = x[9]
                        parm.modulation = x[6]
                        parm.rolloff = x[8]
                        parm.pilot = x[9]

+                       parm.is_id = x[10]
+                       parm.pls_mode = x[11]
+                       parm.pls_code = x[12]

                        tlist.append(parm)
 
 def getInitialCableTransponderList(tlist, nim):
                        tlist.append(parm)
 
 def getInitialCableTransponderList(tlist, nim):


@@ -67,7 +71,7 @@ def getInitialCableTransponderList(tlist, nim):
                        #print "inversion:", 2
                        tlist.append(parm)
 
                        #print "inversion:", 2
                        tlist.append(parm)
 

-def getInitialTerrestrialTransponderList(tlist, region):
+def getInitialTerrestrialTransponderList(tlist, region, skip_t2 = False):

        list = nimmanager.getTranspondersTerrestrial(region)
 
        #self.transponders[self.parsedTer].append((2,freq,bw,const,crh,crl,guard,transm,hierarchy,inv,system,plpid))
        list = nimmanager.getTranspondersTerrestrial(region)
 
        #self.transponders[self.parsedTer].append((2,freq,bw,const,crh,crl,guard,transm,hierarchy,inv,system,plpid))


@@ -77,6 +81,9 @@ def getInitialTerrestrialTransponderList(tlist, region):
 
        for x in list:
                if x[0] == 2: #TERRESTRIAL
 
        for x in list:
                if x[0] == 2: #TERRESTRIAL

+                       if skip_t2 and x[10] == eDVBFrontendParametersTerrestrial.System_DVB_T2:
+                               # Should be searching on TerrestrialTransponderSearchSupport.
+                               continue

                        parm = buildTerTransponder(x[1], x[9], x[2], x[4], x[5], x[3], x[7], x[6], x[8], x[10], x[11])
                        tlist.append(parm)
 
                        parm = buildTerTransponder(x[1], x[9], x[2], x[4], x[5], x[3], x[7], x[6], x[8], x[10], x[11])
                        tlist.append(parm)
 


@@ -95,6 +102,45 @@ cable_bands = {
        "DVBC_BAND_US_HYPER" : 1 << 11,
 }
 
        "DVBC_BAND_US_HYPER" : 1 << 11,
 }
 

+cable_autoscan_nimtype = {
+'SSH108' : 'ssh108',
+'TT3L10' : 'tt3l10',
+'TURBO' : 'vuplus_turbo_c',
+'TT2L08' : 'tt2l08',
+'BCM3148' : 'bcm3148',
+'BCM3158' : 'bcm3148',
+}
+
+terrestrial_autoscan_nimtype = {
+'SSH108' : 'ssh108_t2_scan',
+'TT3L10' : 'tt3l10_t2_scan',
+'TURBO' : 'vuplus_turbo_t',
+'TT2L08' : 'tt2l08_t2_scan',
+'BCM3466' : 'bcm3466'
+}
+
+dual_tuner_list = ('TT3L10', 'BCM3466')
+
+def GetDeviceId(filter, nim_idx):
+       tuners={}
+       device_id = 0
+       socket_id = 0
+       for nim in nimmanager.nim_slots:
+               name_token = nim.description.split(' ')
+               name = name_token[-1][4:-1]
+               if name == filter:
+                       if socket_id == nim_idx:
+                               break
+
+                       if device_id:   device_id = 0
+                       else:                   device_id = 1
+               socket_id += 1
+       return device_id
+
+def GetTerrestrial5VEnable(nim_idx):
+       nim = nimmanager.nim_slots[nim_idx]
+       return int(nim.config.terrestrial_5V.value)
+

 class CableTransponderSearchSupport:
 #      def setCableTransponderSearchResult(self, tlist):
 #              pass
 class CableTransponderSearchSupport:
 #      def setCableTransponderSearchResult(self, tlist):
 #              pass


@@ -170,32 +216,26 @@ class CableTransponderSearchSupport:
                        self.cable_search_session["text"].setText(tmpstr)
 
        def startCableTransponderSearch(self, nim_idx):
                        self.cable_search_session["text"].setText(tmpstr)
 
        def startCableTransponderSearch(self, nim_idx):

-               def GetCommand(nimIdx):
-                       _supportNimType   = { 'SSH108':'ssh108' }
-                       _nimSocket = {}
-                       fp = file('/proc/bus/nim_sockets')
-
-                       sNo, sName = -1, ""
-                       for line in fp:
-                               line = line.strip()
-                               if line.startswith('NIM Socket'):
-                                       try:    sNo = line.split()[2][:-1]
-                                       except: sNo = -1
-                               elif line.startswith('Name:'):
-                                       try:    sName = line.split()[3][4:-1]
-                                       except: sName = ""
-                               if sNo >= 0 and sName != "":
-                                       _nimSocket[sNo] = sName
-                                       sNo, sName = -1, ''
-                       fp.close()
-                       print 'parsed nim_sockets :', _nimSocket
-
+               def GetCommand(nim_idx):
+                       global cable_autoscan_nimtype

                        try:
                        try:

-                               sName = _nimSocket[str(nimIdx)]
-                               sType = _supportNimType[sName]
-                               return sType
-                       except: pass
-                       return 'tda1002x'
+                               nim_name = nimmanager.getNimName(nim_idx)
+                               if nim_name is not None and nim_name != "":
+                                       device_id = ""
+                                       nim_name = nim_name.strip(':VTUNER').split(' ')[-1][4:-1]
+                                       if nim_name == 'TT3L10':
+                                               try:
+                                                       device_id = GetDeviceId('TT3L10', nim_idx)
+                                                       device_id = "--device=%s" % (device_id)
+                                               except Exception, err:
+                                                       print "GetCommand ->", err
+                                                       device_id = "--device=0"
+#                                              print nim_idx, nim_name, cable_autoscan_nimtype[nim_name], device_id
+                                       command = "%s %s" % (cable_autoscan_nimtype[nim_name], device_id)
+                                       return command
+                       except Exception, err:
+                               print "GetCommand ->", err
+                       return "tda1002x"

 
                if not self.tryGetRawFrontend(nim_idx):
                        self.session.nav.stopService()
 
                if not self.tryGetRawFrontend(nim_idx):
                        self.session.nav.stopService()


@@ -322,6 +362,7 @@ class TerrestrialTransponderSearchSupport:
                print self.terrestrial_search_data
                data = self.terrestrial_search_data.split()
                if len(data):
                print self.terrestrial_search_data
                data = self.terrestrial_search_data.split()
                if len(data):

+#                      print "[setTerrestrialTransponderData] data : ", data

                        if data[0] == 'OK':
                                # DVB-T : OK frequency bandwidth delivery system -1
                                # DVB-T2 : OK frequency bandwidth delivery system number_of_plp plp_id0:plp_type0
                        if data[0] == 'OK':
                                # DVB-T : OK frequency bandwidth delivery system -1
                                # DVB-T2 : OK frequency bandwidth delivery system number_of_plp plp_id0:plp_type0


@@ -341,7 +382,7 @@ class TerrestrialTransponderSearchSupport:
                                        self.__tlist.append(parm)
                                else:
                                        plp_list = data[5:]
                                        self.__tlist.append(parm)
                                else:
                                        plp_list = data[5:]

-                                       plp_num = data[4]
+                                       plp_num = int(data[4])

                                        if len(plp_list) > plp_num:
                                                plp_list = plp_list[:plp_num]
                                        for plp in plp_list:
                                        if len(plp_list) > plp_num:
                                                plp_list = plp_list[:plp_num]
                                        for plp in plp_list:


@@ -362,7 +403,7 @@ class TerrestrialTransponderSearchSupport:
                                                parm.plpid = int(plp_id)
                                                self.__tlist.append(parm)
 
                                                parm.plpid = int(plp_id)
                                                self.__tlist.append(parm)
 

-                       tmpstr = _("Try to find used Transponders in cable network.. please wait...")
+                       tmpstr = _("Try to find used Transponders in terrestrial network.. please wait...")

                        tmpstr += "\n\n"
                        tmpstr += data[1][:-3]
                        tmpstr += " kHz "
                        tmpstr += "\n\n"
                        tmpstr += data[1][:-3]
                        tmpstr += " kHz "


@@ -406,16 +447,28 @@ class TerrestrialTransponderSearchSupport:
                else:
                        return None
 
                else:
                        return None
 

-       def startTerrestrialTransponderSearch(self, nim_idx, region):
-               def GetCommand(nimIdx):
-                       _supportNimType   = { 'SSH108':'ssh108_t2_scan' }
-                       description = nimmanager.getNimName(nimIdx)
-                       try:
-                               tunername = description.split()[2][4:-1]
-                       except:
-                               tunername = description
-                       return  _supportNimType.get(tunername, 'ssh108_t2_scan')
+       def terrestrialTransponderGetCmd(self, nim_idx):
+               global terrestrial_autoscan_nimtype
+               try:
+                       nim_name = nimmanager.getNimName(nim_idx)
+                       if nim_name is not None and nim_name != "":
+                               device_id = ""
+                               nim_name = nim_name.strip(':VTUNER').split(' ')[-1][4:-1]
+                               if nim_name in dual_tuner_list:
+                                       try:
+                                               device_id = GetDeviceId(nim_name, nim_idx)
+                                               device_id = "--device %s" % (device_id)
+                                       except Exception, err:
+                                               print "terrestrialTransponderGetCmd ->", err
+                                               device_id = "--device 0"
+#                                      print nim_idx, nim_name, terrestrial_autoscan_nimtype[nim_name], device_id
+                               command = "%s %s" % (terrestrial_autoscan_nimtype[nim_name], device_id)
+                               return command
+               except Exception, err:
+                       print "terrestrialTransponderGetCmd ->", err
+               return ""

 
 

+       def startTerrestrialTransponderSearch(self, nim_idx, region):

                if not self.tryGetRawFrontend(nim_idx):
                        self.session.nav.stopService()
                        if not self.tryGetRawFrontend(nim_idx):
                if not self.tryGetRawFrontend(nim_idx):
                        self.session.nav.stopService()
                        if not self.tryGetRawFrontend(nim_idx):


@@ -430,13 +483,16 @@ class TerrestrialTransponderSearchSupport:
                self.terrestrial_search_container.appClosed.append(self.terrestrialTransponderSearchClosed)
                self.terrestrial_search_container.dataAvail.append(self.getTerrestrialTransponderData)
 
                self.terrestrial_search_container.appClosed.append(self.terrestrialTransponderSearchClosed)
                self.terrestrial_search_container.dataAvail.append(self.getTerrestrialTransponderData)
 

-               self.terrestrial_search_binName = GetCommand(nim_idx)
+               self.terrestrial_search_binName = self.terrestrialTransponderGetCmd(nim_idx)

 
                self.terrestrial_search_bus = nimmanager.getI2CDevice(nim_idx)
                if self.terrestrial_search_bus is None:
 
                self.terrestrial_search_bus = nimmanager.getI2CDevice(nim_idx)
                if self.terrestrial_search_bus is None:

-                       print "ERROR: could not get I2C device for nim", nim_idx, "for terrestrial transponder search"
+#                      print "ERROR: could not get I2C device for nim", nim_idx, "for terrestrial transponder search"

                        self.terrestrial_search_bus = 2
 
                        self.terrestrial_search_bus = 2
 

+               self.terrestrial_search_feid = nim_idx
+               self.terrestrial_search_enable_5v = GetTerrestrial5VEnable(nim_idx)
+

                self.terrestrial_search_list = []
                self.terrestrialTransponderInitSearchList(self.terrestrial_search_list ,region)
                (freq, bandWidth) = self.terrestrialTransponderGetOpt()
                self.terrestrial_search_list = []
                self.terrestrialTransponderInitSearchList(self.terrestrial_search_list ,region)
                (freq, bandWidth) = self.terrestrialTransponderGetOpt()


@@ -448,7 +504,9 @@ class TerrestrialTransponderSearchSupport:
 
        def terrestrialTransponderSearch(self, freq, bandWidth):
                self.terrestrial_search_data = ""
 
        def terrestrialTransponderSearch(self, freq, bandWidth):
                self.terrestrial_search_data = ""

-               cmd = "%s --freq %d --bw %d --bus %d --ds 2" % (self.terrestrial_search_binName, freq, bandWidth, self.terrestrial_search_bus)  
+               cmd = "%s --freq %d --bw %d --bus %d --ds 2" % (self.terrestrial_search_binName, freq, bandWidth, self.terrestrial_search_bus)
+               if self.terrestrial_search_enable_5v:
+                       cmd += " --feid %d --5v %d" % (self.terrestrial_search_feid, self.terrestrial_search_enable_5v)

                print "SCAN CMD : ",cmd
                self.terrestrial_search_container.execute(cmd)
 
                print "SCAN CMD : ",cmd
                self.terrestrial_search_container.execute(cmd)
 


@@ -536,6 +594,8 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport, Terrest
                self.typeOfScanEntry = None
                self.systemEntry = None
                self.modulationEntry = None
                self.typeOfScanEntry = None
                self.systemEntry = None
                self.modulationEntry = None

+               self.is_id_boolEntry = None
+               self.plsModeEntry = None

                nim = nimmanager.nim_slots[index_to_scan]
                if nim.isCompatible("DVB-S"):
                        self.typeOfScanEntry = getConfigListEntry(_("Type of scan"), self.scan_type)
                nim = nimmanager.nim_slots[index_to_scan]
                if nim.isCompatible("DVB-S"):
                        self.typeOfScanEntry = getConfigListEntry(_("Type of scan"), self.scan_type)


@@ -551,7 +611,13 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport, Terrest
                if nim.isCompatible("DVB-S"):
                        if self.scan_type.value == "single_transponder":
                                self.updateSatList()
                if nim.isCompatible("DVB-S"):
                        if self.scan_type.value == "single_transponder":
                                self.updateSatList()

-                               if nim.isCompatible("DVB-S2"):
+
+                               scan_sat_system_value = self.scan_sat.system.value
+                               if nim.isCompatible("DVB-S2X"):
+                                       scan_sat_system_value = self.scan_sat.system_dvbs2x.value
+                                       self.systemEntry = getConfigListEntry(_('System'), self.scan_sat.system_dvbs2x)
+                                       self.list.append(self.systemEntry)
+                               elif nim.isCompatible("DVB-S2"):

                                        self.systemEntry = getConfigListEntry(_('System'), self.scan_sat.system)
                                        self.list.append(self.systemEntry)
                                else:
                                        self.systemEntry = getConfigListEntry(_('System'), self.scan_sat.system)
                                        self.list.append(self.systemEntry)
                                else:


@@ -562,14 +628,45 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport, Terrest
                                self.list.append(getConfigListEntry(_('Inversion'), self.scan_sat.inversion))
                                self.list.append(getConfigListEntry(_('Symbol rate'), self.scan_sat.symbolrate))
                                self.list.append(getConfigListEntry(_('Polarization'), self.scan_sat.polarization))
                                self.list.append(getConfigListEntry(_('Inversion'), self.scan_sat.inversion))
                                self.list.append(getConfigListEntry(_('Symbol rate'), self.scan_sat.symbolrate))
                                self.list.append(getConfigListEntry(_('Polarization'), self.scan_sat.polarization))

-                               if self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S:
-                                       self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec))
-                               elif self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S2:
-                                       self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2))
+
+                               if scan_sat_system_value == eDVBFrontendParametersSatellite.System_DVB_S2:

                                        self.modulationEntry = getConfigListEntry(_('Modulation'), self.scan_sat.modulation)
                                        self.list.append(self.modulationEntry)
                                        self.list.append(getConfigListEntry(_('Roll-off'), self.scan_sat.rolloff))
                                        self.list.append(getConfigListEntry(_('Pilot'), self.scan_sat.pilot))
                                        self.modulationEntry = getConfigListEntry(_('Modulation'), self.scan_sat.modulation)
                                        self.list.append(self.modulationEntry)
                                        self.list.append(getConfigListEntry(_('Roll-off'), self.scan_sat.rolloff))
                                        self.list.append(getConfigListEntry(_('Pilot'), self.scan_sat.pilot))

+                               elif scan_sat_system_value == eDVBFrontendParametersSatellite.System_DVB_S2X:
+                                       self.modulationEntry = getConfigListEntry(_('Modulation'), self.scan_sat.modulation_dvbs2x)
+                                       self.list.append(self.modulationEntry)
+                                       self.list.append(getConfigListEntry(_('Roll-off'), self.scan_sat.rolloff))
+                                       self.list.append(getConfigListEntry(_('Pilot'), self.scan_sat.pilot))
+
+                               if scan_sat_system_value == eDVBFrontendParametersSatellite.System_DVB_S:
+                                       self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec))
+                               elif scan_sat_system_value == eDVBFrontendParametersSatellite.System_DVB_S2:
+                                       self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2))
+                               elif scan_sat_system_value == eDVBFrontendParametersSatellite.System_DVB_S2X:
+                                       if self.scan_sat.modulation_dvbs2x.value == eDVBFrontendParametersSatellite.Modulation_QPSK:
+                                               self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2x_qpsk))
+                                       elif self.scan_sat.modulation_dvbs2x.value == eDVBFrontendParametersSatellite.Modulation_8PSK:
+                                               self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2x_8psk))
+                                       elif self.scan_sat.modulation_dvbs2x.value == eDVBFrontendParametersSatellite.Modulation_8APSK:
+                                               self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2x_8apsk))
+                                       elif self.scan_sat.modulation_dvbs2x.value == eDVBFrontendParametersSatellite.Modulation_16APSK:
+                                               self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2x_16apsk))
+                                       elif self.scan_sat.modulation_dvbs2x.value == eDVBFrontendParametersSatellite.Modulation_32APSK:
+                                               self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2x_32apsk))
+
+                               if scan_sat_system_value in (eDVBFrontendParametersSatellite.System_DVB_S2, eDVBFrontendParametersSatellite.System_DVB_S2X):
+                                       if nim.isMultistream():
+                                               self.is_id_boolEntry = getConfigListEntry(_('Transport Stream Type'), self.scan_sat.is_id_bool)
+                                               self.list.append(self.is_id_boolEntry)
+                                               if self.scan_sat.is_id_bool.value:
+                                                       self.list.append(getConfigListEntry(_('Input Stream ID'), self.scan_sat.is_id))
+                                                       self.plsModeEntry = getConfigListEntry(_('PLS Mode'), self.scan_sat.pls_mode)
+                                                       self.list.append(self.plsModeEntry)
+                                                       if self.scan_sat.pls_mode.value != eDVBFrontendParametersSatellite.PLS_Unknown:
+                                                               self.list.append(getConfigListEntry(_('PLS Code'), self.scan_sat.pls_code))
+

                        elif self.scan_type.value == "single_satellite":
                                self.updateSatList()
                                print self.scan_satselection[index_to_scan]
                        elif self.scan_type.value == "single_satellite":
                                self.updateSatList()
                                print self.scan_satselection[index_to_scan]


@@ -636,43 +733,20 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport, Terrest
        def newConfig(self):
                cur = self["config"].getCurrent()
                print "cur is", cur
        def newConfig(self):
                cur = self["config"].getCurrent()
                print "cur is", cur

+               if cur is None:
+                       return
+

                if cur == self.typeOfScanEntry or \
                        cur == self.tunerEntry or \
                        cur == self.systemEntry or \
                if cur == self.typeOfScanEntry or \
                        cur == self.tunerEntry or \
                        cur == self.systemEntry or \

-                       (self.modulationEntry and self.systemEntry[1].value == eDVBFrontendParametersSatellite.System_DVB_S2 and cur == self.modulationEntry):
+                       (self.modulationEntry and \
+                       (self.systemEntry[1].value in (eDVBFrontendParametersSatellite.System_DVB_S2, eDVBFrontendParametersSatellite.System_DVB_S2X)) and \
+                       cur == self.modulationEntry) or \
+                       cur == self.is_id_boolEntry or \
+                       cur == self.plsModeEntry:

                        self.createSetup()
 
        def createConfig(self, frontendData):
                        self.createSetup()
 
        def createConfig(self, frontendData):

-                                                          #("Type", frontendData["system"], TYPE_TEXT),
-                                          #("Modulation", frontendData["modulation"], TYPE_TEXT),
-                                          #("Orbital position", frontendData["orbital_position"], TYPE_VALUE_DEC),
-                                          #("Frequency", frontendData["frequency"], TYPE_VALUE_DEC),
-                                          #("Symbolrate", frontendData["symbol_rate"], TYPE_VALUE_DEC),
-                                          #("Polarization", frontendData["polarization"], TYPE_TEXT),
-                                          #("Inversion", frontendData["inversion"], TYPE_TEXT),
-                                          #("FEC inner", frontendData["fec_inner"], TYPE_TEXT),
-                                               #)
-               #elif frontendData["tuner_type"] == "DVB-C":
-                       #return ( ("NIM", ['A', 'B', 'C', 'D'][frontendData["tuner_number"]], TYPE_TEXT),
-                                          #("Type", frontendData["tuner_type"], TYPE_TEXT),
-                                          #("Frequency", frontendData["frequency"], TYPE_VALUE_DEC),
-                                          #("Symbolrate", frontendData["symbol_rate"], TYPE_VALUE_DEC),
-                                          #("Modulation", frontendData["modulation"], TYPE_TEXT),
-                                          #("Inversion", frontendData["inversion"], TYPE_TEXT),
-                       #                  ("FEC inner", frontendData["fec_inner"], TYPE_TEXT),
-                                               #)
-               #elif frontendData["tuner_type"] == "DVB-T":
-                       #return ( ("NIM", ['A', 'B', 'C', 'D'][frontendData["tuner_number"]], TYPE_TEXT),
-                                          #("Type", frontendData["tuner_type"], TYPE_TEXT),
-                                          #("Frequency", frontendData["frequency"], TYPE_VALUE_DEC),
-                                          #("Inversion", frontendData["inversion"], TYPE_TEXT),
-                                          #("Bandwidth", frontendData["bandwidth"], TYPE_VALUE_DEC),
-                                          #("CodeRateLP", frontendData["code_rate_lp"], TYPE_TEXT),
-                                          #("CodeRateHP", frontendData["code_rate_hp"], TYPE_TEXT),
-                                          #("Constellation", frontendData["constellation"], TYPE_TEXT),
-                                          #("Transmission Mode", frontendData["transmission_mode"], TYPE_TEXT),
-                                          #("Guard Interval", frontendData["guard_interval"], TYPE_TEXT),
-                                          #("Hierarchy Inform.", frontendData["hierarchy_information"], TYPE_TEXT),

                        defaultSat = {
                                "orbpos": 192,
                                "system": eDVBFrontendParametersSatellite.System_DVB_S,
                        defaultSat = {
                                "orbpos": 192,
                                "system": eDVBFrontendParametersSatellite.System_DVB_S,


@@ -682,7 +756,16 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport, Terrest
                                "polarization": eDVBFrontendParametersSatellite.Polarisation_Horizontal,
                                "fec": eDVBFrontendParametersSatellite.FEC_Auto,
                                "fec_s2": eDVBFrontendParametersSatellite.FEC_9_10,
                                "polarization": eDVBFrontendParametersSatellite.Polarisation_Horizontal,
                                "fec": eDVBFrontendParametersSatellite.FEC_Auto,
                                "fec_s2": eDVBFrontendParametersSatellite.FEC_9_10,

-                               "modulation": eDVBFrontendParametersSatellite.Modulation_QPSK }
+                               "fec_s2x_qpsk": eDVBFrontendParametersSatellite.FEC_13_45,
+                               "fec_s2x_8psk": eDVBFrontendParametersSatellite.FEC_23_36,
+                               "fec_s2x_8apsk": eDVBFrontendParametersSatellite.FEC_5_9_L,
+                               "fec_s2x_16apsk": eDVBFrontendParametersSatellite.FEC_1_2_L,
+                               "fec_s2x_32apsk": eDVBFrontendParametersSatellite.FEC_2_3_L,
+                               "modulation": eDVBFrontendParametersSatellite.Modulation_QPSK,
+                               "modulation_s2x": eDVBFrontendParametersSatellite.Modulation_QPSK,
+                               "is_id": -1,
+                               "pls_mode": eDVBFrontendParametersSatellite.PLS_Unknown,
+                               "pls_code": 0 }

                        defaultCab = {
                                "frequency": 466,
                                "inversion": eDVBFrontendParametersCable.Inversion_Unknown,
                        defaultCab = {
                                "frequency": 466,
                                "inversion": eDVBFrontendParametersCable.Inversion_Unknown,


@@ -710,14 +793,37 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport, Terrest
                                        defaultSat["inversion"] = frontendData.get("inversion", eDVBFrontendParametersSatellite.Inversion_Unknown)
                                        defaultSat["symbolrate"] = frontendData.get("symbol_rate", 0) / 1000
                                        defaultSat["polarization"] = frontendData.get("polarization", eDVBFrontendParametersSatellite.Polarisation_Horizontal)
                                        defaultSat["inversion"] = frontendData.get("inversion", eDVBFrontendParametersSatellite.Inversion_Unknown)
                                        defaultSat["symbolrate"] = frontendData.get("symbol_rate", 0) / 1000
                                        defaultSat["polarization"] = frontendData.get("polarization", eDVBFrontendParametersSatellite.Polarisation_Horizontal)

+                                       defaultSat["orbpos"] = frontendData.get("orbital_position", 0)
+
+                                       defaultSat["modulation"] = frontendData.get("modulation", eDVBFrontendParametersSatellite.Modulation_QPSK)
+                                       defaultSat["modulation_s2x"] = frontendData.get("modulation", eDVBFrontendParametersSatellite.Modulation_QPSK)
+
+                                       if defaultSat["modulation"] > eDVBFrontendParametersSatellite.Modulation_8PSK:
+                                               defaultSat["modulation"] = eDVBFrontendParametersSatellite.Modulation_8PSK
+

                                        if defaultSat["system"] == eDVBFrontendParametersSatellite.System_DVB_S2:
                                                defaultSat["fec_s2"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto)
                                        if defaultSat["system"] == eDVBFrontendParametersSatellite.System_DVB_S2:
                                                defaultSat["fec_s2"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto)

-                                               defaultSat["rolloff"] = frontendData.get("rolloff", eDVBFrontendParametersSatellite.RollOff_alpha_0_35)
-                                               defaultSat["pilot"] = frontendData.get("pilot", eDVBFrontendParametersSatellite.Pilot_Unknown)
+                                       elif defaultSat["system"] == eDVBFrontendParametersSatellite.System_DVB_S2X:
+                                               if defaultSat["modulation_s2x"] == eDVBFrontendParametersSatellite.Modulation_QPSK:
+                                                       defaultSat["fec_s2x_qpsk"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_13_45)
+                                               elif defaultSat["modulation_s2x"] == eDVBFrontendParametersSatellite.Modulation_8PSK:
+                                                       defaultSat["fec_s2x_8psk"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_23_36)
+                                               elif defaultSat["modulation_s2x"] == eDVBFrontendParametersSatellite.Modulation_8APSK:
+                                                       defaultSat["fec_s2x_8apsk"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_5_9_L)
+                                               elif defaultSat["modulation_s2x"] == eDVBFrontendParametersSatellite.Modulation_16APSK:
+                                                       defaultSat["fec_s2x_16apsk"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_1_2_L)
+                                               elif defaultSat["modulation_s2x"] == eDVBFrontendParametersSatellite.Modulation_32APSK:
+                                                       defaultSat["fec_s2x_32apsk"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_2_3_L)

                                        else:
                                                defaultSat["fec"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto)
                                        else:
                                                defaultSat["fec"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto)

-                                       defaultSat["modulation"] = frontendData.get("modulation", eDVBFrontendParametersSatellite.Modulation_QPSK)
-                                       defaultSat["orbpos"] = frontendData.get("orbital_position", 0)
+
+                                       if defaultSat["system"] in (eDVBFrontendParametersSatellite.System_DVB_S2, eDVBFrontendParametersSatellite.System_DVB_S2X):
+                                               defaultSat["rolloff"] = frontendData.get("rolloff", eDVBFrontendParametersSatellite.RollOff_alpha_0_35)
+                                               defaultSat["pilot"] = frontendData.get("pilot", eDVBFrontendParametersSatellite.Pilot_Unknown)
+                                               defaultSat["is_id"] = frontendData.get("is_id", defaultSat["is_id"])
+                                               defaultSat["pls_mode"] = frontendData.get("pls_mode", defaultSat["pls_mode"])
+                                               defaultSat["pls_code"] = frontendData.get("pls_code", defaultSat["pls_code"])
+

                                elif ttype == "DVB-C":
                                        defaultCab["frequency"] = frontendData.get("frequency", 0) / 1000
                                        defaultCab["symbolrate"] = frontendData.get("symbol_rate", 0) / 1000
                                elif ttype == "DVB-C":
                                        defaultCab["frequency"] = frontendData.get("frequency", 0) / 1000
                                        defaultCab["symbolrate"] = frontendData.get("symbol_rate", 0) / 1000


@@ -772,9 +878,21 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport, Terrest
                        self.scan_ber.enabled = False
 
                        # sat
                        self.scan_ber.enabled = False
 
                        # sat

-                       self.scan_sat.system = ConfigSelection(default = defaultSat["system"], choices = [
+                       sat_choices = [
+                               (eDVBFrontendParametersSatellite.System_DVB_S, _("DVB-S")),
+                               (eDVBFrontendParametersSatellite.System_DVB_S2, _("DVB-S2"))]
+
+                       sat_choices_dvbs2x = [

                                (eDVBFrontendParametersSatellite.System_DVB_S, _("DVB-S")),
                                (eDVBFrontendParametersSatellite.System_DVB_S, _("DVB-S")),

-                               (eDVBFrontendParametersSatellite.System_DVB_S2, _("DVB-S2"))])
+                               (eDVBFrontendParametersSatellite.System_DVB_S2, _("DVB-S2")),
+                               (eDVBFrontendParametersSatellite.System_DVB_S2X, _("DVB-S2X"))]
+
+                       default_sat_system = defaultSat["system"]
+                       if default_sat_system not in sat_choices:
+                               default_sat_system = eDVBFrontendParametersSatellite.System_DVB_S
+
+                       self.scan_sat.system = ConfigSelection(default = default_sat_system, choices = sat_choices)
+                       self.scan_sat.system_dvbs2x = ConfigSelection(default = defaultSat["system"], choices = sat_choices_dvbs2x)

                        self.scan_sat.frequency = ConfigInteger(default = defaultSat["frequency"], limits = (1, 99999))
                        self.scan_sat.inversion = ConfigSelection(default = defaultSat["inversion"], choices = [
                                (eDVBFrontendParametersSatellite.Inversion_Off, _("Off")),
                        self.scan_sat.frequency = ConfigInteger(default = defaultSat["frequency"], limits = (1, 99999))
                        self.scan_sat.inversion = ConfigSelection(default = defaultSat["inversion"], choices = [
                                (eDVBFrontendParametersSatellite.Inversion_Off, _("Off")),


@@ -804,9 +922,51 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport, Terrest
                                (eDVBFrontendParametersSatellite.FEC_7_8, "7/8"),
                                (eDVBFrontendParametersSatellite.FEC_8_9, "8/9"),
                                (eDVBFrontendParametersSatellite.FEC_9_10, "9/10")])
                                (eDVBFrontendParametersSatellite.FEC_7_8, "7/8"),
                                (eDVBFrontendParametersSatellite.FEC_8_9, "8/9"),
                                (eDVBFrontendParametersSatellite.FEC_9_10, "9/10")])

+
+                       self.scan_sat.fec_s2x_qpsk = ConfigSelection(default = defaultSat["fec_s2x_qpsk"], choices = [
+                               (eDVBFrontendParametersSatellite.FEC_13_45, "13/45"),
+                               (eDVBFrontendParametersSatellite.FEC_9_20, "9/20"),
+                               (eDVBFrontendParametersSatellite.FEC_11_20, "11/20")])
+
+                       self.scan_sat.fec_s2x_8psk = ConfigSelection(default = defaultSat["fec_s2x_8psk"], choices = [
+                               (eDVBFrontendParametersSatellite.FEC_23_36, "23/36"),
+                               (eDVBFrontendParametersSatellite.FEC_25_36, "25/36"),
+                               (eDVBFrontendParametersSatellite.FEC_13_18, "13/28")])
+
+                       self.scan_sat.fec_s2x_8apsk = ConfigSelection(default = defaultSat["fec_s2x_8apsk"], choices = [
+                               (eDVBFrontendParametersSatellite.FEC_5_9_L, "5/9-L"),
+                               (eDVBFrontendParametersSatellite.FEC_26_45_L, "26/45-L")])
+
+                       self.scan_sat.fec_s2x_16apsk = ConfigSelection(default = defaultSat["fec_s2x_16apsk"], choices = [
+                               (eDVBFrontendParametersSatellite.FEC_1_2_L, "1/2-L"),
+                               (eDVBFrontendParametersSatellite.FEC_8_15_L, "8/15-L"),
+                               (eDVBFrontendParametersSatellite.FEC_5_9_L, "5/9-L"),
+                               (eDVBFrontendParametersSatellite.FEC_26_45, "26/45"),
+                               (eDVBFrontendParametersSatellite.FEC_3_5, "3/5"),
+                               (eDVBFrontendParametersSatellite.FEC_3_5_L, "3/5-L"),
+                               (eDVBFrontendParametersSatellite.FEC_28_45, "28/45"),
+                               (eDVBFrontendParametersSatellite.FEC_23_36, "23/36"),
+                               (eDVBFrontendParametersSatellite.FEC_2_3_L, "2/3-L"),
+                               (eDVBFrontendParametersSatellite.FEC_25_36, "25/36"),
+                               (eDVBFrontendParametersSatellite.FEC_13_18, "13/18"),
+                               (eDVBFrontendParametersSatellite.FEC_7_9, "7/9"),
+                               (eDVBFrontendParametersSatellite.FEC_77_90, "77/90")])
+
+                       self.scan_sat.fec_s2x_32apsk = ConfigSelection(default = defaultSat["fec_s2x_32apsk"], choices = [
+                               (eDVBFrontendParametersSatellite.FEC_2_3_L, "2/3-L"),
+                               (eDVBFrontendParametersSatellite.FEC_32_45, "32/45"),
+                               (eDVBFrontendParametersSatellite.FEC_11_15, "11/15"),
+                               (eDVBFrontendParametersSatellite.FEC_7_9, "7/9")])
+

                        self.scan_sat.modulation = ConfigSelection(default = defaultSat["modulation"], choices = [
                                (eDVBFrontendParametersSatellite.Modulation_QPSK, "QPSK"),
                                (eDVBFrontendParametersSatellite.Modulation_8PSK, "8PSK")])
                        self.scan_sat.modulation = ConfigSelection(default = defaultSat["modulation"], choices = [
                                (eDVBFrontendParametersSatellite.Modulation_QPSK, "QPSK"),
                                (eDVBFrontendParametersSatellite.Modulation_8PSK, "8PSK")])

+                       self.scan_sat.modulation_dvbs2x = ConfigSelection(default = defaultSat["modulation_s2x"], choices = [
+                               (eDVBFrontendParametersSatellite.Modulation_QPSK, "QPSK"),
+                               (eDVBFrontendParametersSatellite.Modulation_8PSK, "8PSK"),
+                               (eDVBFrontendParametersSatellite.Modulation_8APSK, "8APSK"),
+                               (eDVBFrontendParametersSatellite.Modulation_16APSK, "16APSK"),
+                               (eDVBFrontendParametersSatellite.Modulation_32APSK, "32APSK")])

                        self.scan_sat.rolloff = ConfigSelection(default = defaultSat.get("rolloff", eDVBFrontendParametersSatellite.RollOff_alpha_0_35), choices = [
                                (eDVBFrontendParametersSatellite.RollOff_alpha_0_35, "0.35"),
                                (eDVBFrontendParametersSatellite.RollOff_alpha_0_25, "0.25"),
                        self.scan_sat.rolloff = ConfigSelection(default = defaultSat.get("rolloff", eDVBFrontendParametersSatellite.RollOff_alpha_0_35), choices = [
                                (eDVBFrontendParametersSatellite.RollOff_alpha_0_35, "0.35"),
                                (eDVBFrontendParametersSatellite.RollOff_alpha_0_25, "0.25"),


@@ -815,6 +975,14 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport, Terrest
                                (eDVBFrontendParametersSatellite.Pilot_Off, _("Off")),
                                (eDVBFrontendParametersSatellite.Pilot_On, _("On")),
                                (eDVBFrontendParametersSatellite.Pilot_Unknown, _("Auto"))])
                                (eDVBFrontendParametersSatellite.Pilot_Off, _("Off")),
                                (eDVBFrontendParametersSatellite.Pilot_On, _("On")),
                                (eDVBFrontendParametersSatellite.Pilot_Unknown, _("Auto"))])

+                       self.scan_sat.is_id = ConfigInteger(default = defaultSat["is_id"] if defaultSat["is_id"] != -1 else 0, limits = (0, 255))
+                       self.scan_sat.is_id_bool = ConfigSelection(default = defaultSat["is_id"] != -1, choices = [(True, _("Multistream")),(False, _("Ordinary"))])
+                       self.scan_sat.pls_mode = ConfigSelection(default = defaultSat["pls_mode"], choices = [
+                               (eDVBFrontendParametersSatellite.PLS_Root, _("Root")),
+                               (eDVBFrontendParametersSatellite.PLS_Gold, _("Gold")),
+                               (eDVBFrontendParametersSatellite.PLS_Combo, _("Combo")),
+                               (eDVBFrontendParametersSatellite.PLS_Unknown, _("Auto"))])
+                       self.scan_sat.pls_code = ConfigInteger(default = defaultSat["pls_code"], limits = (0, 262143))

 
                        # cable
                        self.scan_cab.frequency = ConfigInteger(default = defaultCab["frequency"], limits = (50, 999))
 
                        # cable
                        self.scan_cab.frequency = ConfigInteger(default = defaultCab["frequency"], limits = (50, 999))


@@ -964,8 +1132,8 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport, Terrest
        def updateStatus(self):
                print "updatestatus"
 
        def updateStatus(self):
                print "updatestatus"
 

-       def addSatTransponder(self, tlist, frequency, symbol_rate, polarisation, fec, inversion, orbital_position, system, modulation, rolloff, pilot):
-               print "Add Sat: frequ: " + str(frequency) + " symbol: " + str(symbol_rate) + " pol: " + str(polarisation) + " fec: " + str(fec) + " inversion: " + str(inversion) + " modulation: " + str(modulation) + " system: " + str(system) + " rolloff" + str(rolloff) + " pilot" + str(pilot)
+       def addSatTransponder(self, tlist, frequency, symbol_rate, polarisation, fec, inversion, orbital_position, system, modulation, rolloff, pilot, is_id, pls_mode, pls_code):
+               print "Add Sat: frequ: " + str(frequency) + " symbol: " + str(symbol_rate) + " pol: " + str(polarisation) + " fec: " + str(fec) + " inversion: " + str(inversion) + " modulation: " + str(modulation) + " system: " + str(system) + " rolloff" + str(rolloff) + " pilot" + str(pilot) + " is_id" + str(is_id) + " pls_mode" + str(pls_mode) + " pls_code" + str(pls_code)

                print "orbpos: " + str(orbital_position)
                parm = eDVBFrontendParametersSatellite()
                parm.modulation = modulation
                print "orbpos: " + str(orbital_position)
                parm = eDVBFrontendParametersSatellite()
                parm.modulation = modulation


@@ -978,6 +1146,9 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport, Terrest
                parm.orbital_position = orbital_position
                parm.rolloff = rolloff
                parm.pilot = pilot
                parm.orbital_position = orbital_position
                parm.rolloff = rolloff
                parm.pilot = pilot

+               parm.is_id = is_id
+               parm.pls_mode = pls_mode
+               parm.pls_code = pls_code

                tlist.append(parm)
 
        def addCabTransponder(self, tlist, frequency, symbol_rate, modulation, fec, inversion):
                tlist.append(parm)
 
        def addCabTransponder(self, tlist, frequency, symbol_rate, modulation, fec, inversion):


@@ -1022,13 +1193,45 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport, Terrest
                                nimsats = self.satList[index_to_scan]
                                selsatidx = self.scan_satselection[index_to_scan].index
 
                                nimsats = self.satList[index_to_scan]
                                selsatidx = self.scan_satselection[index_to_scan].index
 

+                               modulation = self.scan_sat.modulation.value

                                # however, the satList itself could be empty. in that case, "index" is 0 (for "None").
                                if len(nimsats):
                                        orbpos = nimsats[selsatidx][0]
                                # however, the satList itself could be empty. in that case, "index" is 0 (for "None").
                                if len(nimsats):
                                        orbpos = nimsats[selsatidx][0]

-                                       if self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S:
+
+                                       system = self.scan_sat.system.value
+                                       if nim.isCompatible("DVB-S2X"):
+                                               system = self.scan_sat.system_dvbs2x.value
+
+                                       if system == eDVBFrontendParametersSatellite.System_DVB_S:

                                                fec = self.scan_sat.fec.value
                                                fec = self.scan_sat.fec.value

+                                       elif system == eDVBFrontendParametersSatellite.System_DVB_S2:
+                                               fec = self.scan_sat.fec_s2.value
+                                       elif system == eDVBFrontendParametersSatellite.System_DVB_S2X:
+                                               modulation = self.scan_sat.modulation_dvbs2x.value
+                                               if modulation == eDVBFrontendParametersSatellite.Modulation_QPSK:
+                                                       fec = self.scan_sat.fec_s2x_qpsk.value
+                                               elif modulation == eDVBFrontendParametersSatellite.Modulation_8PSK:
+                                                       fec = self.scan_sat.fec_s2x_8psk.value
+                                               elif modulation == eDVBFrontendParametersSatellite.Modulation_8APSK:
+                                                       fec = self.scan_sat.fec_s2x_8apsk.value
+                                               elif modulation == eDVBFrontendParametersSatellite.Modulation_16APSK:
+                                                       fec = self.scan_sat.fec_s2x_16apsk.value
+                                               elif modulation == eDVBFrontendParametersSatellite.Modulation_32APSK:
+                                                       fec = self.scan_sat.fec_s2x_32apsk.value

                                        else:
                                                fec = self.scan_sat.fec_s2.value
                                        else:
                                                fec = self.scan_sat.fec_s2.value

+
+                                       is_id = -1
+                                       pls_mode = eDVBFrontendParametersSatellite.PLS_Unknown
+                                       pls_code = 0
+                                       if self.scan_sat.is_id_bool.value:
+                                               is_id = self.scan_sat.is_id.value
+                                               pls_mode = self.scan_sat.pls_mode.value
+                                               if pls_mode == eDVBFrontendParametersSatellite.PLS_Unknown:
+                                                       pls_code = 0
+                                               else:
+                                                       pls_code = self.scan_sat.pls_code.value
+

                                        print "add sat transponder"
                                        self.addSatTransponder(tlist, self.scan_sat.frequency.value,
                                                                self.scan_sat.symbolrate.value,
                                        print "add sat transponder"
                                        self.addSatTransponder(tlist, self.scan_sat.frequency.value,
                                                                self.scan_sat.symbolrate.value,


@@ -1036,10 +1239,13 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport, Terrest
                                                                fec,
                                                                self.scan_sat.inversion.value,
                                                                orbpos,
                                                                fec,
                                                                self.scan_sat.inversion.value,
                                                                orbpos,

-                                                               self.scan_sat.system.value,
-                                                               self.scan_sat.modulation.value,
+                                                               system,
+                                                               modulation,

                                                                self.scan_sat.rolloff.value,
                                                                self.scan_sat.rolloff.value,

-                                                               self.scan_sat.pilot.value)
+                                                               self.scan_sat.pilot.value,
+                                                               is_id,
+                                                               pls_mode,
+                                                               pls_code)

                                removeAll = False
                        elif self.scan_type.value == "single_satellite":
                                sat = self.satList[index_to_scan][self.scan_satselection[index_to_scan].index]
                                removeAll = False
                        elif self.scan_type.value == "single_satellite":
                                sat = self.satList[index_to_scan][self.scan_satselection[index_to_scan].index]


@@ -1095,9 +1301,15 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport, Terrest
                                                        plpid = self.scan_ter.plp_id.value)
                                removeAll = False
                        elif self.scan_typeterrestrial.value == "complete":
                                                        plpid = self.scan_ter.plp_id.value)
                                removeAll = False
                        elif self.scan_typeterrestrial.value == "complete":

-                               getInitialTerrestrialTransponderList(tlist, nimmanager.getTerrestrialDescription(index_to_scan))
+                               skip_t2 = True

                                if nim.isCompatible("DVB-T2"):
                                if nim.isCompatible("DVB-T2"):

-                                       action = SEARCH_TERRESTRIAL2_TRANSPONDERS
+                                       scan_util = len(self.terrestrialTransponderGetCmd(nim.slot)) and True or False
+                                       if scan_util:
+                                               action = SEARCH_TERRESTRIAL2_TRANSPONDERS
+                                       else:
+                                               skip_t2 = False
+
+                               getInitialTerrestrialTransponderList(tlist, nimmanager.getTerrestrialDescription(index_to_scan), skip_t2)

 
                flags = self.scan_networkScan.value and eComponentScan.scanNetworkSearch or 0
 
 
                flags = self.scan_networkScan.value and eComponentScan.scanNetworkSearch or 0
 


@@ -1172,7 +1384,7 @@ class ScanSimple(ConfigListScreen, Screen, CableTransponderSearchSupport, Terres
                if nim.isCompatible("DVB-S"):
                        networks = nimmanager.getSatListForNim(nim.slot)
                elif not nim.empty:
                if nim.isCompatible("DVB-S"):
                        networks = nimmanager.getSatListForNim(nim.slot)
                elif not nim.empty:

-                       networks = [ nim.type ] # "DVB-C" or "DVB-T". TODO: seperate networks for different C/T tuners, if we want to support that.
+                       networks = [ nim.getType() ] # "DVB-C" or "DVB-T". TODO: seperate networks for different C/T tuners, if we want to support that.

                else:
                        # empty tuners provide no networks.
                        networks = [ ]
                else:
                        # empty tuners provide no networks.
                        networks = [ ]


@@ -1195,8 +1407,11 @@ class ScanSimple(ConfigListScreen, Screen, CableTransponderSearchSupport, Terres
                self.finished_cb = None
 
                for nim in nimmanager.nim_slots:
                self.finished_cb = None
 
                for nim in nimmanager.nim_slots:

-                       # collect networks provided by this tuner
+                       # don't offer to scan nims if nothing is connected
+                       if not nimmanager.somethingConnected(nim.slot):
+                               continue

 
 

+                       # collect networks provided by this tuner

                        need_scan = False
                        networks = self.getNetworksForNim(nim)
                        
                        need_scan = False
                        networks = self.getNetworksForNim(nim)
                        


@@ -1210,10 +1425,6 @@ class ScanSimple(ConfigListScreen, Screen, CableTransponderSearchSupport, Terres
                                        need_scan = True
                                        print x, "not in ", known_networks
                                        known_networks.append(x)
                                        need_scan = True
                                        print x, "not in ", known_networks
                                        known_networks.append(x)

-                                       
-                       # don't offer to scan nims if nothing is connected
-                       if not nimmanager.somethingConnected(nim.slot):
-                               need_scan = False                               

 
                        if need_scan:
                                nims_to_scan.append(nim)
 
                        if need_scan:
                                nims_to_scan.append(nim)


@@ -1222,7 +1433,7 @@ class ScanSimple(ConfigListScreen, Screen, CableTransponderSearchSupport, Terres
                if "DVB-T2" in known_networks: # we need to remove "DVB-T" when networks have "DVB-T2"
                        nims_dvb_t = []
                        for nim in nims_to_scan:
                if "DVB-T2" in known_networks: # we need to remove "DVB-T" when networks have "DVB-T2"
                        nims_dvb_t = []
                        for nim in nims_to_scan:

-                               if nim.type == "DVB-T":
+                               if nim.getType() == "DVB-T":

                                        nims_dvb_t.append(nim)
 
                        for nim in nims_dvb_t:
                                        nims_dvb_t.append(nim)
 
                        for nim in nims_dvb_t:


@@ -1283,9 +1494,14 @@ class ScanSimple(ConfigListScreen, Screen, CableTransponderSearchSupport, Terres
                                        else:
                                                action = SEARCH_CABLE_TRANSPONDERS
                                elif nim.isCompatible("DVB-T"):
                                        else:
                                                action = SEARCH_CABLE_TRANSPONDERS
                                elif nim.isCompatible("DVB-T"):

-                                       getInitialTerrestrialTransponderList(tlist, nimmanager.getTerrestrialDescription(nim.slot))
+                                       skip_t2 = True

                                        if nim.isCompatible("DVB-T2"):
                                        if nim.isCompatible("DVB-T2"):

-                                               action = SEARCH_TERRESTRIAL2_TRANSPONDERS
+                                               scan_util = len(self.terrestrialTransponderGetCmd(nim.slot)) and True or False
+                                               if scan_util:
+                                                       action = SEARCH_TERRESTRIAL2_TRANSPONDERS
+                                               else:
+                                                       skip_t2 = False
+                                       getInitialTerrestrialTransponderList(tlist, nimmanager.getTerrestrialDescription(nim.slot), skip_t2)

                                else:
                                        assert False
 
                                else:
                                        assert False