Support turbo2.
[vuplus_dvbapp] / lib / python / Screens / ScanSetup.py
index f8bfeb7..87a58f7 100644 (file)
@@ -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
@@ -17,7 +18,7 @@ from enigma import eTimer, eDVBFrontendParametersSatellite, eComponentScan, \
 def buildTerTransponder(frequency, 
                inversion=2, bandwidth = 3, fechigh = 6, feclow = 6,
                modulation = 2, transmission = 2, guard = 4,
 def buildTerTransponder(frequency, 
                inversion=2, bandwidth = 3, fechigh = 6, feclow = 6,
                modulation = 2, transmission = 2, guard = 4,
-               hierarchy = 4):
+               hierarchy = 4, system = 0, plpid = 0):
 #      print "freq", frequency, "inv", inversion, "bw", bandwidth, "fech", fechigh, "fecl", feclow, "mod", modulation, "tm", transmission, "guard", guard, "hierarchy", hierarchy
        parm = eDVBFrontendParametersTerrestrial()
        parm.frequency = frequency
 #      print "freq", frequency, "inv", inversion, "bw", bandwidth, "fech", fechigh, "fecl", feclow, "mod", modulation, "tm", transmission, "guard", guard, "hierarchy", hierarchy
        parm = eDVBFrontendParametersTerrestrial()
        parm.frequency = frequency
@@ -29,6 +30,8 @@ def buildTerTransponder(frequency,
        parm.transmission_mode = transmission
        parm.guard_interval = guard
        parm.hierarchy = hierarchy
        parm.transmission_mode = transmission
        parm.guard_interval = guard
        parm.hierarchy = hierarchy
+       parm.system = system
+       parm.plpid = plpid
        return parm
 
 def getInitialTransponderList(tlist, pos):
        return parm
 
 def getInitialTransponderList(tlist, pos):
@@ -46,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):
@@ -65,17 +71,20 @@ 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)
 
        list = nimmanager.getTranspondersTerrestrial(region)
 
-       #self.transponders[self.parsedTer].append((2,freq,bw,const,crh,crl,guard,transm,hierarchy,inv))
+       #self.transponders[self.parsedTer].append((2,freq,bw,const,crh,crl,guard,transm,hierarchy,inv,system,plpid))
 
        #def buildTerTransponder(frequency, inversion = 2, bandwidth = 3, fechigh = 6, feclow = 6,
 
        #def buildTerTransponder(frequency, inversion = 2, bandwidth = 3, fechigh = 6, feclow = 6,
-                               #modulation = 2, transmission = 2, guard = 4, hierarchy = 4):
+                               #modulation = 2, transmission = 2, guard = 4, hierarchy = 4, system = 0, plpid = 0):):
 
        for x in list:
                if x[0] == 2: #TERRESTRIAL
 
        for x in list:
                if x[0] == 2: #TERRESTRIAL
-                       parm = buildTerTransponder(x[1], x[9], x[2], x[4], x[5], x[3], x[7], x[6], x[8])
+                       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)
 
 cable_bands = {
                        tlist.append(parm)
 
 cable_bands = {
@@ -93,6 +102,59 @@ 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',
+'TURBO2' : 'vuplus_turbo2_c',
+'TT2L08' : 'tt2l08',
+'BCM3148' : 'bcm3148',
+'BCM3158' : 'bcm3148',
+}
+
+terrestrial_autoscan_nimtype = {
+'SSH108' : 'ssh108_t2_scan',
+'TT3L10' : 'tt3l10_t2_scan',
+'TURBO' : 'vuplus_turbo_t',
+'TURBO2' : 'vuplus_turbo2_t',
+'TT2L08' : 'tt2l08_t2_scan',
+'BCM3466' : 'bcm3466'
+}
+
+dual_tuner_list = ('TT3L10', 'BCM3466')
+vtuner_need_idx_list = ('TURBO2')
+
+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 getVtunerId(filter, nim_idx):
+       idx_count = 1
+       for slot in nimmanager.nim_slots:
+               slot_idx = slot.slot
+               if filter in slot.description:
+                       if slot_idx == nim_idx :
+                               return "--idx " + str(idx_count)
+                       else:
+                               idx_count += 1
+       return ""
+
+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
@@ -168,6 +230,29 @@ 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(nim_idx):
+                       global cable_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 == '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
+                                       elif nim_name in vtuner_need_idx_list:
+                                               device_id = getVtunerId(nim_name, nim_idx)
+                                       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):
                if not self.tryGetRawFrontend(nim_idx):
                        self.session.nav.stopService()
                        if not self.tryGetRawFrontend(nim_idx):
@@ -191,8 +276,9 @@ class CableTransponderSearchSupport:
                if tunername == "CXD1981":
                        cmd = "cxd1978 --init --scan --verbose --wakeup --inv 2 --bus %d" % bus
                else:
                if tunername == "CXD1981":
                        cmd = "cxd1978 --init --scan --verbose --wakeup --inv 2 --bus %d" % bus
                else:
-                       cmd = "tda1002x --init --scan --verbose --wakeup --inv 2 --bus %d" % bus
-               
+                       bin_name = GetCommand(nim_idx)
+                       cmd = "%(BIN_NAME)s --init --scan --verbose --wakeup --inv 2 --bus %(BUS)d" % {'BIN_NAME':bin_name , 'BUS':bus}
+
                if cableConfig.scan_type.value == "bands":
                        cmd += " --scan-bands "
                        bands = 0
                if cableConfig.scan_type.value == "bands":
                        cmd += " --scan-bands "
                        bands = 0
@@ -246,13 +332,202 @@ class CableTransponderSearchSupport:
                        cmd += " --sr "
                        cmd += str(cableConfig.scan_sr_ext2.value)
                        cmd += "000"
                        cmd += " --sr "
                        cmd += str(cableConfig.scan_sr_ext2.value)
                        cmd += "000"
-               print "TDA1002x CMD is", cmd
+               print bin_name, " CMD is", cmd
 
                self.cable_search_container.execute(cmd)
                tmpstr = _("Try to find used transponders in cable network.. please wait...")
                tmpstr += "\n\n..."
                self.cable_search_session = self.session.openWithCallback(self.cableTransponderSearchSessionClosed, MessageBox, tmpstr, MessageBox.TYPE_INFO)
 
 
                self.cable_search_container.execute(cmd)
                tmpstr = _("Try to find used transponders in cable network.. please wait...")
                tmpstr += "\n\n..."
                self.cable_search_session = self.session.openWithCallback(self.cableTransponderSearchSessionClosed, MessageBox, tmpstr, MessageBox.TYPE_INFO)
 
+class TerrestrialTransponderSearchSupport:
+#      def setTerrestrialTransponderSearchResult(self, tlist):
+#              pass
+
+#      def terrestrialTransponderSearchFinished(self):
+#              pass
+
+       def terrestrialTransponderSearchSessionClosed(self, *val):
+               print "TerrestrialTransponderSearchSessionClosed, val", val
+               self.terrestrial_search_container.appClosed.remove(self.terrestrialTransponderSearchClosed)
+               self.terrestrial_search_container.dataAvail.remove(self.getTerrestrialTransponderData)
+               if val and len(val):
+                       if val[0]:
+                               self.setTerrestrialTransponderSearchResult(self.__tlist)
+                       else:
+                               self.terrestrial_search_container.sendCtrlC()
+                               self.setTerrestrialTransponderSearchResult(None)
+               self.terrestrial_search_container = None
+               self.terrestrial_search_session = None
+               self.__tlist = None
+               self.terrestrialTransponderSearchFinished()
+
+       def terrestrialTransponderSearchClosed(self, retval):
+               self.setTerrestrialTransponderData()
+               opt = self.terrestrialTransponderGetOpt()
+               if opt is None:
+                       print "terrestrialTransponderSearch finished", retval
+                       self.terrestrial_search_session.close(True)
+               else:
+                       (freq, bandWidth) = opt
+                       self.terrestrialTransponderSearch(freq, bandWidth)
+
+       def getTerrestrialTransponderData(self, str):
+               self.terrestrial_search_data += str
+
+       def setTerrestrialTransponderData(self):
+               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[3] == 1: # DVB-T
+                                       parm = eDVBFrontendParametersTerrestrial()
+                                       parm.frequency = int(data[1])
+                                       parm.bandwidth = int(data[2])
+                                       parm.inversion = parm.Inversion_Unknown
+                                       parm.code_rate_HP = parm.FEC_Auto
+                                       parm.code_rate_LP = parm.FEC_Auto
+                                       parm.modulation = parm.Modulation_Auto
+                                       parm.transmission_mode = parm.TransmissionMode_Auto
+                                       parm.guard_interval = parm.GuardInterval_Auto
+                                       parm.hierarchy = parm.Hierarchy_Auto
+                                       parm.system = parm.System_DVB_T
+                                       parm.plpid = 0
+                                       self.__tlist.append(parm)
+                               else:
+                                       plp_list = data[5:]
+                                       plp_num = int(data[4])
+                                       if len(plp_list) > plp_num:
+                                               plp_list = plp_list[:plp_num]
+                                       for plp in plp_list:
+                                               (plp_id, plp_type) = plp.split(':')
+                                               if plp_type == '0': # common PLP:
+                                                       continue
+                                               parm = eDVBFrontendParametersTerrestrial()
+                                               parm.frequency = int(data[1])
+                                               parm.bandwidth = self.terrestrialTransponderconvBandwidth_P(int(data[2]))
+                                               parm.inversion = parm.Inversion_Unknown
+                                               parm.code_rate_HP = parm.FEC_Auto
+                                               parm.code_rate_LP = parm.FEC_Auto
+                                               parm.modulation = parm.Modulation_Auto
+                                               parm.transmission_mode = parm.TransmissionMode_Auto
+                                               parm.guard_interval = parm.GuardInterval_Auto
+                                               parm.hierarchy = parm.Hierarchy_Auto
+                                               parm.system = parm.System_DVB_T2
+                                               parm.plpid = int(plp_id)
+                                               self.__tlist.append(parm)
+
+                       tmpstr = _("Try to find used Transponders in terrestrial network.. please wait...")
+                       tmpstr += "\n\n"
+                       tmpstr += data[1][:-3]
+                       tmpstr += " kHz "
+                       tmpstr += data[0]
+                       self.terrestrial_search_session["text"].setText(tmpstr)
+
+       def terrestrialTransponderInitSearchList(self, searchList, region):
+               tpList = nimmanager.getTranspondersTerrestrial(region)
+               for x in tpList:
+                       if x[0] == 2: #TERRESTRIAL
+                               freq = x[1] # frequency
+                               bandWidth = self.terrestrialTransponderConvBandwidth_I(x[2]) # bandWidth
+                               parm = (freq, bandWidth)
+                               searchList.append(parm)
+
+       def terrestrialTransponderConvBandwidth_I(self, _bandWidth):
+               bandWidth = {
+                       eDVBFrontendParametersTerrestrial.Bandwidth_8MHz : 8000000,
+                       eDVBFrontendParametersTerrestrial.Bandwidth_7MHz : 7000000,
+                       eDVBFrontendParametersTerrestrial.Bandwidth_6MHz : 6000000,
+                       eDVBFrontendParametersTerrestrial.Bandwidth_5MHz : 5000000,
+                       eDVBFrontendParametersTerrestrial.Bandwidth_1_712MHz : 1712000,
+                       eDVBFrontendParametersTerrestrial.Bandwidth_10MHz : 10000000,
+               }.get(_bandWidth, 8000000)
+               return bandWidth
+
+       def terrestrialTransponderconvBandwidth_P(self, _bandWidth):
+               bandWidth = {
+                       8000000 : eDVBFrontendParametersTerrestrial.Bandwidth_8MHz,
+                       7000000 : eDVBFrontendParametersTerrestrial.Bandwidth_7MHz,
+                       6000000 : eDVBFrontendParametersTerrestrial.Bandwidth_6MHz,
+                       5000000 : eDVBFrontendParametersTerrestrial.Bandwidth_5MHz,
+                       1712000 : eDVBFrontendParametersTerrestrial.Bandwidth_1_712MHz,
+                       10000000 : eDVBFrontendParametersTerrestrial.Bandwidth_10MHz,
+               }.get(_bandWidth, eDVBFrontendParametersTerrestrial.Bandwidth_8MHz)
+               return bandWidth
+
+       def terrestrialTransponderGetOpt(self):
+               if len(self.terrestrial_search_list) > 0:
+                       return self.terrestrial_search_list.pop(0)
+               else:
+                       return None
+
+       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
+                               elif nim_name in vtuner_need_idx_list:
+                                       device_id = getVtunerId(nim_name, nim_idx)
+                               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 self.session.pipshown: # try to disable pip
+                                       self.session.pipshown = False
+                                       del self.session.pip
+                               if not self.tryGetRawFrontend(nim_idx):
+                                       self.terrestrialTransponderSearchFinished()
+                                       return
+               self.__tlist = [ ]
+               self.terrestrial_search_container = eConsoleAppContainer()
+               self.terrestrial_search_container.appClosed.append(self.terrestrialTransponderSearchClosed)
+               self.terrestrial_search_container.dataAvail.append(self.getTerrestrialTransponderData)
+
+               self.terrestrial_search_binName = self.terrestrialTransponderGetCmd(nim_idx)
+
+               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"
+                       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.terrestrialTransponderSearch(freq, bandWidth)
+
+               tmpstr = _("Try to find used transponders in terrestrial network.. please wait...")
+               tmpstr += "\n\n..."
+               self.terrestrial_search_session = self.session.openWithCallback(self.terrestrialTransponderSearchSessionClosed, MessageBox, tmpstr, MessageBox.TYPE_INFO)
+
+       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)
+               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)
+
 class DefaultSatLists(DefaultWizard):
        def __init__(self, session, silent = True, showSteps = False):
                self.xmlfile = "defaultsatlists.xml"
 class DefaultSatLists(DefaultWizard):
        def __init__(self, session, silent = True, showSteps = False):
                self.xmlfile = "defaultsatlists.xml"
@@ -274,7 +549,7 @@ class DefaultSatLists(DefaultWizard):
                        self.markDone()
                        self.disableKeys = False        
 
                        self.markDone()
                        self.disableKeys = False        
 
-class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
+class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport, TerrestrialTransponderSearchSupport):
        def __init__(self, session):
                Screen.__init__(self, session)
 
        def __init__(self, session):
                Screen.__init__(self, session)
 
@@ -337,6 +612,8 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
                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)
@@ -352,7 +629,13 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
                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:
@@ -363,14 +646,45 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
                                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]
@@ -396,15 +710,32 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
                                self.list.append(getConfigListEntry(_("FEC"), self.scan_cab.fec))
                elif nim.isCompatible("DVB-T"):
                        if self.scan_typeterrestrial.value == "single_transponder":
                                self.list.append(getConfigListEntry(_("FEC"), self.scan_cab.fec))
                elif nim.isCompatible("DVB-T"):
                        if self.scan_typeterrestrial.value == "single_transponder":
-                               self.list.append(getConfigListEntry(_("Frequency"), self.scan_ter.frequency))
-                               self.list.append(getConfigListEntry(_("Inversion"), self.scan_ter.inversion))
-                               self.list.append(getConfigListEntry(_("Bandwidth"), self.scan_ter.bandwidth))
-                               self.list.append(getConfigListEntry(_("Code rate HP"), self.scan_ter.fechigh))
-                               self.list.append(getConfigListEntry(_("Code rate LP"), self.scan_ter.feclow))
-                               self.list.append(getConfigListEntry(_("Modulation"), self.scan_ter.modulation))
-                               self.list.append(getConfigListEntry(_("Transmission mode"), self.scan_ter.transmission))
-                               self.list.append(getConfigListEntry(_("Guard interval"), self.scan_ter.guard))
-                               self.list.append(getConfigListEntry(_("Hierarchy info"), self.scan_ter.hierarchy))
+                               if nim.isCompatible("DVB-T2"):
+                                       self.systemEntry = getConfigListEntry(_('System'), self.scan_ter.system)
+                                       self.list.append(self.systemEntry)
+                               else:
+                                       self.scan_ter.system.value = eDVBFrontendParametersTerrestrial.System_DVB_T
+                               if self.scan_ter.system.value == eDVBFrontendParametersTerrestrial.System_DVB_T:
+                                       self.list.append(getConfigListEntry(_("Frequency"), self.scan_ter.frequency))
+                                       self.list.append(getConfigListEntry(_("Inversion"), self.scan_ter.inversion))
+                                       self.list.append(getConfigListEntry(_("Bandwidth"), self.scan_ter.bandwidth))
+                                       self.list.append(getConfigListEntry(_("Code rate HP"), self.scan_ter.fechigh))
+                                       self.list.append(getConfigListEntry(_("Code rate LP"), self.scan_ter.feclow))
+                                       self.list.append(getConfigListEntry(_("Modulation"), self.scan_ter.modulation))
+                                       self.list.append(getConfigListEntry(_("Transmission mode"), self.scan_ter.transmission))
+                                       self.list.append(getConfigListEntry(_("Guard interval"), self.scan_ter.guard))
+                                       self.list.append(getConfigListEntry(_("Hierarchy info"), self.scan_ter.hierarchy))
+                               else: # DVB-T2
+                                       self.list.append(getConfigListEntry(_("Frequency"), self.scan_ter.frequency))
+                                       self.list.append(getConfigListEntry(_("Inversion"), self.scan_ter.inversion))
+                                       self.list.append(getConfigListEntry(_("Bandwidth"), self.scan_ter.bandwidth_t2))
+                                       self.list.append(getConfigListEntry(_("Code rate HP"), self.scan_ter.fechigh_t2))
+                                       self.list.append(getConfigListEntry(_("Code rate LP"), self.scan_ter.feclow_t2))
+                                       self.list.append(getConfigListEntry(_("Modulation"), self.scan_ter.modulation_t2))
+                                       self.list.append(getConfigListEntry(_("Transmission mode"), self.scan_ter.transmission_t2))
+                                       self.list.append(getConfigListEntry(_("Guard interval"), self.scan_ter.guard_t2))
+                                       self.list.append(getConfigListEntry(_("Hierarchy info"), self.scan_ter.hierarchy))
+                                       self.list.append(getConfigListEntry(_('PLP ID'), self.scan_ter.plp_id))
                self.list.append(getConfigListEntry(_("Network scan"), self.scan_networkScan))
                self.list.append(getConfigListEntry(_("Clear before scan"), self.scan_clearallservices))
                self.list.append(getConfigListEntry(_("Only Free scan"), self.scan_onlyfree))
                self.list.append(getConfigListEntry(_("Network scan"), self.scan_networkScan))
                self.list.append(getConfigListEntry(_("Clear before scan"), self.scan_clearallservices))
                self.list.append(getConfigListEntry(_("Only Free scan"), self.scan_onlyfree))
@@ -420,43 +751,20 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
        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,
@@ -466,7 +774,16 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
                                "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,
@@ -482,7 +799,9 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
                                "modulation" : eDVBFrontendParametersTerrestrial.Modulation_Auto,
                                "transmission_mode" : eDVBFrontendParametersTerrestrial.TransmissionMode_Auto,
                                "guard_interval" : eDVBFrontendParametersTerrestrial.GuardInterval_Auto,
                                "modulation" : eDVBFrontendParametersTerrestrial.Modulation_Auto,
                                "transmission_mode" : eDVBFrontendParametersTerrestrial.TransmissionMode_Auto,
                                "guard_interval" : eDVBFrontendParametersTerrestrial.GuardInterval_Auto,
-                               "hierarchy": eDVBFrontendParametersTerrestrial.Hierarchy_Auto }
+                               "hierarchy": eDVBFrontendParametersTerrestrial.Hierarchy_Auto,
+                               "system": eDVBFrontendParametersTerrestrial.System_DVB_T,
+                               "plp_id": 0 }
 
                        if frontendData is not None:
                                ttype = frontendData.get("tuner_type", "UNKNOWN")
 
                        if frontendData is not None:
                                ttype = frontendData.get("tuner_type", "UNKNOWN")
@@ -492,14 +811,37 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
                                        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
@@ -507,7 +849,7 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
                                        defaultCab["fec"] = frontendData.get("fec_inner", eDVBFrontendParametersCable.FEC_Auto)
                                        defaultCab["modulation"] = frontendData.get("modulation", eDVBFrontendParametersCable.Modulation_QAM16)
                                elif ttype == "DVB-T":
                                        defaultCab["fec"] = frontendData.get("fec_inner", eDVBFrontendParametersCable.FEC_Auto)
                                        defaultCab["modulation"] = frontendData.get("modulation", eDVBFrontendParametersCable.Modulation_QAM16)
                                elif ttype == "DVB-T":
-                                       defaultTer["frequency"] = frontendData.get("frequency", 0)
+                                       defaultTer["frequency"] = frontendData.get("frequency", 0) / 1000
                                        defaultTer["inversion"] = frontendData.get("inversion", eDVBFrontendParametersTerrestrial.Inversion_Unknown)
                                        defaultTer["bandwidth"] = frontendData.get("bandwidth", eDVBFrontendParametersTerrestrial.Bandwidth_7MHz)
                                        defaultTer["fechigh"] = frontendData.get("code_rate_hp", eDVBFrontendParametersTerrestrial.FEC_Auto)
                                        defaultTer["inversion"] = frontendData.get("inversion", eDVBFrontendParametersTerrestrial.Inversion_Unknown)
                                        defaultTer["bandwidth"] = frontendData.get("bandwidth", eDVBFrontendParametersTerrestrial.Bandwidth_7MHz)
                                        defaultTer["fechigh"] = frontendData.get("code_rate_hp", eDVBFrontendParametersTerrestrial.FEC_Auto)
@@ -516,6 +858,8 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
                                        defaultTer["transmission_mode"] = frontendData.get("transmission_mode", eDVBFrontendParametersTerrestrial.TransmissionMode_Auto)
                                        defaultTer["guard_interval"] = frontendData.get("guard_interval", eDVBFrontendParametersTerrestrial.GuardInterval_Auto)
                                        defaultTer["hierarchy"] = frontendData.get("hierarchy_information", eDVBFrontendParametersTerrestrial.Hierarchy_Auto)
                                        defaultTer["transmission_mode"] = frontendData.get("transmission_mode", eDVBFrontendParametersTerrestrial.TransmissionMode_Auto)
                                        defaultTer["guard_interval"] = frontendData.get("guard_interval", eDVBFrontendParametersTerrestrial.GuardInterval_Auto)
                                        defaultTer["hierarchy"] = frontendData.get("hierarchy_information", eDVBFrontendParametersTerrestrial.Hierarchy_Auto)
+                                       defaultTer["system"] = frontendData.get("system", eDVBFrontendParametersTerrestrial.System_DVB_T)
+                                       defaultTer["plp_id"] = frontendData.get("plp_id", 0)
 
                        self.scan_sat = ConfigSubsection()
                        self.scan_cab = ConfigSubsection()
 
                        self.scan_sat = ConfigSubsection()
                        self.scan_cab = ConfigSubsection()
@@ -552,9 +896,21 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
                        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")),
@@ -584,9 +940,51 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
                                (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"),
@@ -595,6 +993,14 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
                                (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))
@@ -620,7 +1026,7 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
                        self.scan_cab.symbolrate = ConfigInteger(default = defaultCab["symbolrate"], limits = (1, 99999))
 
                        # terrestial
                        self.scan_cab.symbolrate = ConfigInteger(default = defaultCab["symbolrate"], limits = (1, 99999))
 
                        # terrestial
-                       self.scan_ter.frequency = ConfigInteger(default = 466000, limits = (50000, 999000))
+                       self.scan_ter.frequency = ConfigInteger(default = defaultTer["frequency"], limits = (50000, 999000))
                        self.scan_ter.inversion = ConfigSelection(default = defaultTer["inversion"], choices = [
                                (eDVBFrontendParametersTerrestrial.Inversion_Off, _("Off")),
                                (eDVBFrontendParametersTerrestrial.Inversion_On, _("On")),
                        self.scan_ter.inversion = ConfigSelection(default = defaultTer["inversion"], choices = [
                                (eDVBFrontendParametersTerrestrial.Inversion_Off, _("Off")),
                                (eDVBFrontendParametersTerrestrial.Inversion_On, _("On")),
@@ -630,6 +1036,13 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
                                (eDVBFrontendParametersTerrestrial.Bandwidth_8MHz, "8MHz"),
                                (eDVBFrontendParametersTerrestrial.Bandwidth_7MHz, "7MHz"),
                                (eDVBFrontendParametersTerrestrial.Bandwidth_6MHz, "6MHz")])
                                (eDVBFrontendParametersTerrestrial.Bandwidth_8MHz, "8MHz"),
                                (eDVBFrontendParametersTerrestrial.Bandwidth_7MHz, "7MHz"),
                                (eDVBFrontendParametersTerrestrial.Bandwidth_6MHz, "6MHz")])
+                       self.scan_ter.bandwidth_t2 = ConfigSelection(default = defaultTer["bandwidth"], choices = [
+                               (eDVBFrontendParametersTerrestrial.Bandwidth_10MHz, "10MHz"),
+                               (eDVBFrontendParametersTerrestrial.Bandwidth_8MHz, "8MHz"),
+                               (eDVBFrontendParametersTerrestrial.Bandwidth_7MHz, "7MHz"),
+                               (eDVBFrontendParametersTerrestrial.Bandwidth_6MHz, "6MHz"),
+                               (eDVBFrontendParametersTerrestrial.Bandwidth_5MHz, "5MHz"),
+                               (eDVBFrontendParametersTerrestrial.Bandwidth_1_712MHz, "1.712MHz")])
                        #, (eDVBFrontendParametersTerrestrial.Bandwidth_Auto, _("Auto"))))
                        self.scan_ter.fechigh = ConfigSelection(default = defaultTer["fechigh"], choices = [
                                (eDVBFrontendParametersTerrestrial.FEC_1_2, "1/2"),
                        #, (eDVBFrontendParametersTerrestrial.Bandwidth_Auto, _("Auto"))))
                        self.scan_ter.fechigh = ConfigSelection(default = defaultTer["fechigh"], choices = [
                                (eDVBFrontendParametersTerrestrial.FEC_1_2, "1/2"),
@@ -638,6 +1051,15 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
                                (eDVBFrontendParametersTerrestrial.FEC_5_6, "5/6"),
                                (eDVBFrontendParametersTerrestrial.FEC_7_8, "7/8"),
                                (eDVBFrontendParametersTerrestrial.FEC_Auto, _("Auto"))])
                                (eDVBFrontendParametersTerrestrial.FEC_5_6, "5/6"),
                                (eDVBFrontendParametersTerrestrial.FEC_7_8, "7/8"),
                                (eDVBFrontendParametersTerrestrial.FEC_Auto, _("Auto"))])
+                       self.scan_ter.fechigh_t2 = ConfigSelection(default = defaultTer["fechigh"], choices = [
+                               (eDVBFrontendParametersTerrestrial.FEC_1_2, "1/2"),
+                               (eDVBFrontendParametersTerrestrial.FEC_2_3, "2/3"),
+                               (eDVBFrontendParametersTerrestrial.FEC_3_4, "3/4"),
+                               (eDVBFrontendParametersTerrestrial.FEC_5_6, "5/6"),
+                               (eDVBFrontendParametersTerrestrial.FEC_6_7, "6/7"),
+                               (eDVBFrontendParametersTerrestrial.FEC_7_8, "7/8"),
+                               (eDVBFrontendParametersTerrestrial.FEC_8_9, "8/9"),
+                               (eDVBFrontendParametersTerrestrial.FEC_Auto, _("Auto"))])
                        self.scan_ter.feclow = ConfigSelection(default = defaultTer["feclow"], choices = [
                                (eDVBFrontendParametersTerrestrial.FEC_1_2, "1/2"),
                                (eDVBFrontendParametersTerrestrial.FEC_2_3, "2/3"),
                        self.scan_ter.feclow = ConfigSelection(default = defaultTer["feclow"], choices = [
                                (eDVBFrontendParametersTerrestrial.FEC_1_2, "1/2"),
                                (eDVBFrontendParametersTerrestrial.FEC_2_3, "2/3"),
@@ -645,27 +1067,63 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
                                (eDVBFrontendParametersTerrestrial.FEC_5_6, "5/6"),
                                (eDVBFrontendParametersTerrestrial.FEC_7_8, "7/8"),
                                (eDVBFrontendParametersTerrestrial.FEC_Auto, _("Auto"))])
                                (eDVBFrontendParametersTerrestrial.FEC_5_6, "5/6"),
                                (eDVBFrontendParametersTerrestrial.FEC_7_8, "7/8"),
                                (eDVBFrontendParametersTerrestrial.FEC_Auto, _("Auto"))])
+                       self.scan_ter.feclow_t2 = ConfigSelection(default = defaultTer["feclow"], choices = [
+                               (eDVBFrontendParametersTerrestrial.FEC_1_2, "1/2"),
+                               (eDVBFrontendParametersTerrestrial.FEC_2_3, "2/3"),
+                               (eDVBFrontendParametersTerrestrial.FEC_3_4, "3/4"),
+                               (eDVBFrontendParametersTerrestrial.FEC_5_6, "5/6"),
+                               (eDVBFrontendParametersTerrestrial.FEC_6_7, "6/7"),
+                               (eDVBFrontendParametersTerrestrial.FEC_7_8, "7/8"),
+                               (eDVBFrontendParametersTerrestrial.FEC_8_9, "8/9"),
+                               (eDVBFrontendParametersTerrestrial.FEC_Auto, _("Auto"))])
                        self.scan_ter.modulation = ConfigSelection(default = defaultTer["modulation"], choices = [
                                (eDVBFrontendParametersTerrestrial.Modulation_QPSK, "QPSK"),
                                (eDVBFrontendParametersTerrestrial.Modulation_QAM16, "QAM16"),
                                (eDVBFrontendParametersTerrestrial.Modulation_QAM64, "QAM64"),
                                (eDVBFrontendParametersTerrestrial.Modulation_Auto, _("Auto"))])
                        self.scan_ter.modulation = ConfigSelection(default = defaultTer["modulation"], choices = [
                                (eDVBFrontendParametersTerrestrial.Modulation_QPSK, "QPSK"),
                                (eDVBFrontendParametersTerrestrial.Modulation_QAM16, "QAM16"),
                                (eDVBFrontendParametersTerrestrial.Modulation_QAM64, "QAM64"),
                                (eDVBFrontendParametersTerrestrial.Modulation_Auto, _("Auto"))])
+                       self.scan_ter.modulation_t2 = ConfigSelection(default = defaultTer["modulation"], choices = [
+                               (eDVBFrontendParametersTerrestrial.Modulation_QPSK, "QPSK"),
+                               (eDVBFrontendParametersTerrestrial.Modulation_QAM16, "QAM16"),
+                               (eDVBFrontendParametersTerrestrial.Modulation_QAM64, "QAM64"),
+                               (eDVBFrontendParametersTerrestrial.Modulation_QAM256, "QAM256"),
+                               (eDVBFrontendParametersTerrestrial.Modulation_Auto, _("Auto"))])
                        self.scan_ter.transmission = ConfigSelection(default = defaultTer["transmission_mode"], choices = [
                                (eDVBFrontendParametersTerrestrial.TransmissionMode_2k, "2K"),
                                (eDVBFrontendParametersTerrestrial.TransmissionMode_8k, "8K"),
                                (eDVBFrontendParametersTerrestrial.TransmissionMode_Auto, _("Auto"))])
                        self.scan_ter.transmission = ConfigSelection(default = defaultTer["transmission_mode"], choices = [
                                (eDVBFrontendParametersTerrestrial.TransmissionMode_2k, "2K"),
                                (eDVBFrontendParametersTerrestrial.TransmissionMode_8k, "8K"),
                                (eDVBFrontendParametersTerrestrial.TransmissionMode_Auto, _("Auto"))])
+                       self.scan_ter.transmission_t2 = ConfigSelection(default = defaultTer["transmission_mode"], choices = [
+                               (eDVBFrontendParametersTerrestrial.TransmissionMode_1k, "1K"),
+                               (eDVBFrontendParametersTerrestrial.TransmissionMode_2k, "2K"),
+                               (eDVBFrontendParametersTerrestrial.TransmissionMode_4k, "4K"),
+                               (eDVBFrontendParametersTerrestrial.TransmissionMode_8k, "8K"),
+                               (eDVBFrontendParametersTerrestrial.TransmissionMode_16k, "16K"),
+                               (eDVBFrontendParametersTerrestrial.TransmissionMode_32k, "32K"),
+                               (eDVBFrontendParametersTerrestrial.TransmissionMode_Auto, _("Auto"))])
                        self.scan_ter.guard = ConfigSelection(default = defaultTer["guard_interval"], choices = [
                                (eDVBFrontendParametersTerrestrial.GuardInterval_1_32, "1/32"),
                                (eDVBFrontendParametersTerrestrial.GuardInterval_1_16, "1/16"),
                                (eDVBFrontendParametersTerrestrial.GuardInterval_1_8, "1/8"),
                                (eDVBFrontendParametersTerrestrial.GuardInterval_1_4, "1/4"),
                                (eDVBFrontendParametersTerrestrial.GuardInterval_Auto, _("Auto"))])
                        self.scan_ter.guard = ConfigSelection(default = defaultTer["guard_interval"], choices = [
                                (eDVBFrontendParametersTerrestrial.GuardInterval_1_32, "1/32"),
                                (eDVBFrontendParametersTerrestrial.GuardInterval_1_16, "1/16"),
                                (eDVBFrontendParametersTerrestrial.GuardInterval_1_8, "1/8"),
                                (eDVBFrontendParametersTerrestrial.GuardInterval_1_4, "1/4"),
                                (eDVBFrontendParametersTerrestrial.GuardInterval_Auto, _("Auto"))])
+                       self.scan_ter.guard_t2 = ConfigSelection(default = defaultTer["guard_interval"], choices = [
+                               (eDVBFrontendParametersTerrestrial.GuardInterval_19_256, "19/256"),
+                               (eDVBFrontendParametersTerrestrial.GuardInterval_19_128, "19/128"),
+                               (eDVBFrontendParametersTerrestrial.GuardInterval_1_128, "1/128"),
+                               (eDVBFrontendParametersTerrestrial.GuardInterval_1_32, "1/32"),
+                               (eDVBFrontendParametersTerrestrial.GuardInterval_1_16, "1/16"),
+                               (eDVBFrontendParametersTerrestrial.GuardInterval_1_8, "1/8"),
+                               (eDVBFrontendParametersTerrestrial.GuardInterval_1_4, "1/4"),
+                               (eDVBFrontendParametersTerrestrial.GuardInterval_Auto, _("Auto"))])
                        self.scan_ter.hierarchy = ConfigSelection(default = defaultTer["hierarchy"], choices = [
                                (eDVBFrontendParametersTerrestrial.Hierarchy_None, _("None")),
                                (eDVBFrontendParametersTerrestrial.Hierarchy_1, "1"),
                                (eDVBFrontendParametersTerrestrial.Hierarchy_2, "2"),
                                (eDVBFrontendParametersTerrestrial.Hierarchy_4, "4"),
                                (eDVBFrontendParametersTerrestrial.Hierarchy_Auto, _("Auto"))])
                        self.scan_ter.hierarchy = ConfigSelection(default = defaultTer["hierarchy"], choices = [
                                (eDVBFrontendParametersTerrestrial.Hierarchy_None, _("None")),
                                (eDVBFrontendParametersTerrestrial.Hierarchy_1, "1"),
                                (eDVBFrontendParametersTerrestrial.Hierarchy_2, "2"),
                                (eDVBFrontendParametersTerrestrial.Hierarchy_4, "4"),
                                (eDVBFrontendParametersTerrestrial.Hierarchy_Auto, _("Auto"))])
+                       self.scan_ter.system = ConfigSelection(default = defaultTer["system"], choices = [
+                               (eDVBFrontendParametersTerrestrial.System_DVB_T, _("DVB-T")),
+                               (eDVBFrontendParametersTerrestrial.System_DVB_T2, _("DVB-T2"))])
+                       self.scan_ter.plp_id = ConfigInteger(default = defaultTer["plp_id"], limits = (0, 255))
 
                        self.scan_scansat = {}
                        for sat in nimmanager.satList:
 
                        self.scan_scansat = {}
                        for sat in nimmanager.satList:
@@ -692,8 +1150,8 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
        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
@@ -706,6 +1164,9 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
                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):
@@ -722,11 +1183,15 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
                tlist.append(buildTerTransponder(*args, **kwargs))
 
        def keyGo(self):
                tlist.append(buildTerTransponder(*args, **kwargs))
 
        def keyGo(self):
+               START_SCAN =0
+               SEARCH_CABLE_TRANSPONDERS = 1
+               SEARCH_TERRESTRIAL2_TRANSPONDERS = 2
+
                if self.scan_nims.value == "":
                        return
                tlist = []
                flags = None
                if self.scan_nims.value == "":
                        return
                tlist = []
                flags = None
-               startScan = True
+               action = START_SCAN
                removeAll = True
                index_to_scan = int(self.scan_nims.value)
                
                removeAll = True
                index_to_scan = int(self.scan_nims.value)
                
@@ -746,13 +1211,45 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
                                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,
@@ -760,10 +1257,13 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
                                                                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]
@@ -787,23 +1287,47 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
                                if config.Nims[index_to_scan].cable.scan_type.value == "provider":
                                        getInitialCableTransponderList(tlist, index_to_scan)
                                else:
                                if config.Nims[index_to_scan].cable.scan_type.value == "provider":
                                        getInitialCableTransponderList(tlist, index_to_scan)
                                else:
-                                       startScan = False
+                                       action = SEARCH_CABLE_TRANSPONDERS
 
                elif nim.isCompatible("DVB-T"):
                        if self.scan_typeterrestrial.value == "single_transponder":
 
                elif nim.isCompatible("DVB-T"):
                        if self.scan_typeterrestrial.value == "single_transponder":
-                               self.addTerTransponder(tlist,
-                                               self.scan_ter.frequency.value * 1000,
-                                               inversion = self.scan_ter.inversion.value,
-                                               bandwidth = self.scan_ter.bandwidth.value,
-                                               fechigh = self.scan_ter.fechigh.value,
-                                               feclow = self.scan_ter.feclow.value,
-                                               modulation = self.scan_ter.modulation.value,
-                                               transmission = self.scan_ter.transmission.value,
-                                               guard = self.scan_ter.guard.value,
-                                               hierarchy = self.scan_ter.hierarchy.value)
+                               if self.scan_ter.system.value == eDVBFrontendParametersTerrestrial.System_DVB_T:
+                                       self.addTerTransponder(tlist,
+                                                       self.scan_ter.frequency.value * 1000,
+                                                       inversion = self.scan_ter.inversion.value,
+                                                       bandwidth = self.scan_ter.bandwidth.value,
+                                                       fechigh = self.scan_ter.fechigh.value,
+                                                       feclow = self.scan_ter.feclow.value,
+                                                       modulation = self.scan_ter.modulation.value,
+                                                       transmission = self.scan_ter.transmission.value,
+                                                       guard = self.scan_ter.guard.value,
+                                                       hierarchy = self.scan_ter.hierarchy.value,
+                                                       system = self.scan_ter.system.value,
+                                                       plpid = self.scan_ter.plp_id.value)
+                               else:
+                                       self.addTerTransponder(tlist,
+                                                       self.scan_ter.frequency.value * 1000,
+                                                       inversion = self.scan_ter.inversion.value,
+                                                       bandwidth = self.scan_ter.bandwidth_t2.value,
+                                                       fechigh = self.scan_ter.fechigh_t2.value,
+                                                       feclow = self.scan_ter.feclow_t2.value,
+                                                       modulation = self.scan_ter.modulation_t2.value,
+                                                       transmission = self.scan_ter.transmission_t2.value,
+                                                       guard = self.scan_ter.guard_t2.value,
+                                                       hierarchy = self.scan_ter.hierarchy.value,
+                                                       system = self.scan_ter.system.value,
+                                                       plpid = self.scan_ter.plp_id.value)
                                removeAll = False
                        elif self.scan_typeterrestrial.value == "complete":
                                removeAll = False
                        elif self.scan_typeterrestrial.value == "complete":
-                               getInitialTerrestrialTransponderList(tlist, nimmanager.getTerrestrialDescription(index_to_scan))
+                               skip_t2 = True
+                               if nim.isCompatible("DVB-T2"):
+                                       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
 
@@ -823,13 +1347,18 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
                for x in self["config"].list:
                        x[1].save()
 
                for x in self["config"].list:
                        x[1].save()
 
-               if startScan:
+               if action == START_SCAN:
                        self.startScan(tlist, flags, index_to_scan)
                        self.startScan(tlist, flags, index_to_scan)
-               else:
+               elif action == SEARCH_CABLE_TRANSPONDERS:
                        self.flags = flags
                        self.feid = index_to_scan
                        self.tlist = []
                        self.startCableTransponderSearch(self.feid)
                        self.flags = flags
                        self.feid = index_to_scan
                        self.tlist = []
                        self.startCableTransponderSearch(self.feid)
+               elif action == SEARCH_TERRESTRIAL2_TRANSPONDERS:
+                       self.flags = flags
+                       self.feid = index_to_scan
+                       self.tlist = tlist
+                       self.startTerrestrialTransponderSearch(self.feid, nimmanager.getTerrestrialDescription(self.feid))
 
        def setCableTransponderSearchResult(self, tlist):
                self.tlist = tlist
 
        def setCableTransponderSearchResult(self, tlist):
                self.tlist = tlist
@@ -840,6 +1369,16 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
                else:
                        self.startScan(self.tlist, self.flags, self.feid)
 
                else:
                        self.startScan(self.tlist, self.flags, self.feid)
 
+       def setTerrestrialTransponderSearchResult(self, tlist):
+               if tlist is not None:
+                       self.tlist.extend(tlist)
+
+       def terrestrialTransponderSearchFinished(self):
+               if self.tlist is None:
+                       self.tlist = []
+               else:
+                       self.startScan(self.tlist, self.flags, self.feid)
+
        def startScan(self, tlist, flags, feid):
                if len(tlist):
                        # flags |= eComponentScan.scanSearchBAT
        def startScan(self, tlist, flags, feid):
                if len(tlist):
                        # flags |= eComponentScan.scanSearchBAT
@@ -858,12 +1397,12 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
                        x[1].cancel()
                self.close()
 
                        x[1].cancel()
                self.close()
 
-class ScanSimple(ConfigListScreen, Screen, CableTransponderSearchSupport):
+class ScanSimple(ConfigListScreen, Screen, CableTransponderSearchSupport, TerrestrialTransponderSearchSupport):
        def getNetworksForNim(self, nim):
                if nim.isCompatible("DVB-S"):
                        networks = nimmanager.getSatListForNim(nim.slot)
                elif not nim.empty:
        def getNetworksForNim(self, nim):
                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 = [ ]
@@ -886,8 +1425,11 @@ class ScanSimple(ConfigListScreen, Screen, CableTransponderSearchSupport):
                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)
                        
@@ -901,14 +1443,20 @@ class ScanSimple(ConfigListScreen, Screen, CableTransponderSearchSupport):
                                        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)
 
+
+               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.getType() == "DVB-T":
+                                       nims_dvb_t.append(nim)
+
+                       for nim in nims_dvb_t:
+                               nims_to_scan.remove(nim)
+
                # we save the config elements to use them on keyGo
                self.nim_enable = [ ]
 
                # we save the config elements to use them on keyGo
                self.nim_enable = [ ]
 
@@ -939,6 +1487,7 @@ class ScanSimple(ConfigListScreen, Screen, CableTransponderSearchSupport):
        def buildTransponderList(self): # this method is called multiple times because of asynchronous stuff
                APPEND_NOW = 0
                SEARCH_CABLE_TRANSPONDERS = 1
        def buildTransponderList(self): # this method is called multiple times because of asynchronous stuff
                APPEND_NOW = 0
                SEARCH_CABLE_TRANSPONDERS = 1
+               SEARCH_TERRESTRIAL2_TRANSPONDERS = 2
                action = APPEND_NOW
 
                n = self.nim_iter < len(self.nim_enable) and self.nim_enable[self.nim_iter] or None
                action = APPEND_NOW
 
                n = self.nim_iter < len(self.nim_enable) and self.nim_enable[self.nim_iter] or None
@@ -963,7 +1512,14 @@ class ScanSimple(ConfigListScreen, Screen, CableTransponderSearchSupport):
                                        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"):
+                                               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
 
@@ -982,6 +1538,12 @@ class ScanSimple(ConfigListScreen, Screen, CableTransponderSearchSupport):
                                        self.feid = nim.slot
                                        self.startCableTransponderSearch(nim.slot)
                                        return
                                        self.feid = nim.slot
                                        self.startCableTransponderSearch(nim.slot)
                                        return
+                               elif action == SEARCH_TERRESTRIAL2_TRANSPONDERS:
+                                       self.tlist = tlist
+                                       self.flags = flags
+                                       self.feid = nim.slot
+                                       self.startTerrestrialTransponderSearch(nim.slot, nimmanager.getTerrestrialDescription(nim.slot))
+                                       return
                                else:
                                        assert False
 
                                else:
                                        assert False
 
@@ -1010,6 +1572,15 @@ class ScanSimple(ConfigListScreen, Screen, CableTransponderSearchSupport):
        def cableTransponderSearchFinished(self):
                self.buildTransponderList()
 
        def cableTransponderSearchFinished(self):
                self.buildTransponderList()
 
+       def setTerrestrialTransponderSearchResult(self, tlist):
+               if tlist is not None:
+                       self.tlist.extend(tlist)
+               if self.tlist is not None:
+                       self.scanList.append({"transponders": self.tlist, "feid": self.feid, "flags": self.flags})
+
+       def terrestrialTransponderSearchFinished(self):
+               self.buildTransponderList()
+
        def keyCancel(self):
                self.close()
 
        def keyCancel(self):
                self.close()