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
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):
#print "inversion:", 2
tlist.append(parm)
-def getInitialTerrestrialTransponderList(tlist, region):
+def getInitialTerrestrialTransponderList(tlist, region, skip_t2 = False):
list = nimmanager.getTranspondersTerrestrial(region)
#self.transponders[self.parsedTer].append((2,freq,bw,const,crh,crl,guard,transm,hierarchy,inv,system,plpid))
for x in list:
if x[0] == 2: #TERRESTRIAL
- if x[10] == eDVBFrontendParametersTerrestrial.System_DVB_T2:
+ 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])
"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
self.cable_search_session["text"].setText(tmpstr)
def startCableTransponderSearch(self, nim_idx):
- def GetCommand(nimIdx):
- _supportNimType = { 'SSH108':'ssh108' }
- _nimSocket = {}
- fp = file('/proc/bus/nim_sockets')
-
- sNo, sName = -1, ""
- for line in fp:
- line = line.strip()
- if line.startswith('NIM Socket'):
- try: sNo = line.split()[2][:-1]
- except: sNo = -1
- elif line.startswith('Name:'):
- try: sName = line.split()[3][4:-1]
- except: sName = ""
- if sNo >= 0 and sName != "":
- _nimSocket[sNo] = sName
- sNo, sName = -1, ''
- fp.close()
- print 'parsed nim_sockets :', _nimSocket
-
+ def GetCommand(nim_idx):
+ global cable_autoscan_nimtype
try:
- sName = _nimSocket[str(nimIdx)]
- sType = _supportNimType[sName]
- return sType
- except: pass
- return 'tda1002x'
+ nim_name = nimmanager.getNimName(nim_idx)
+ if nim_name is not None and nim_name != "":
+ device_id = ""
+ nim_name = nim_name.strip(':VTUNER').split(' ')[-1][4:-1]
+ if nim_name == 'TT3L10':
+ try:
+ device_id = GetDeviceId('TT3L10', nim_idx)
+ device_id = "--device=%s" % (device_id)
+ except Exception, err:
+ print "GetCommand ->", err
+ device_id = "--device=0"
+# print nim_idx, nim_name, cable_autoscan_nimtype[nim_name], device_id
+ 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()
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
self.__tlist.append(parm)
else:
plp_list = data[5:]
- plp_num = data[4]
+ plp_num = int(data[4])
if len(plp_list) > plp_num:
plp_list = plp_list[:plp_num]
for plp in plp_list:
else:
return None
- def startTerrestrialTransponderSearch(self, nim_idx, region):
- def GetCommand(nimIdx):
- _supportNimType = { 'SSH108':'ssh108_t2_scan' }
- description = nimmanager.getNimName(nimIdx)
- try:
- tunername = description.split()[2][4:-1]
- except:
- tunername = description
- return _supportNimType.get(tunername, 'ssh108_t2_scan')
+ def terrestrialTransponderGetCmd(self, nim_idx):
+ global terrestrial_autoscan_nimtype
+ try:
+ nim_name = nimmanager.getNimName(nim_idx)
+ if nim_name is not None and nim_name != "":
+ device_id = ""
+ nim_name = nim_name.strip(':VTUNER').split(' ')[-1][4:-1]
+ if nim_name in dual_tuner_list:
+ try:
+ device_id = GetDeviceId(nim_name, nim_idx)
+ device_id = "--device %s" % (device_id)
+ except Exception, err:
+ print "terrestrialTransponderGetCmd ->", err
+ device_id = "--device 0"
+# print nim_idx, nim_name, terrestrial_autoscan_nimtype[nim_name], device_id
+ 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):
self.terrestrial_search_container.appClosed.append(self.terrestrialTransponderSearchClosed)
self.terrestrial_search_container.dataAvail.append(self.getTerrestrialTransponderData)
- self.terrestrial_search_binName = GetCommand(nim_idx)
+ self.terrestrial_search_binName = self.terrestrialTransponderGetCmd(nim_idx)
self.terrestrial_search_bus = nimmanager.getI2CDevice(nim_idx)
if self.terrestrial_search_bus is None:
- print "ERROR: could not get I2C device for nim", nim_idx, "for terrestrial transponder search"
+# print "ERROR: could not get I2C device for nim", nim_idx, "for terrestrial transponder search"
self.terrestrial_search_bus = 2
+ self.terrestrial_search_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()
def terrestrialTransponderSearch(self, freq, bandWidth):
self.terrestrial_search_data = ""
- cmd = "%s --freq %d --bw %d --bus %d --ds 2" % (self.terrestrial_search_binName, freq, bandWidth, self.terrestrial_search_bus)
+ cmd = "%s --freq %d --bw %d --bus %d --ds 2" % (self.terrestrial_search_binName, freq, bandWidth, self.terrestrial_search_bus)
+ if self.terrestrial_search_enable_5v:
+ cmd += " --feid %d --5v %d" % (self.terrestrial_search_feid, self.terrestrial_search_enable_5v)
print "SCAN CMD : ",cmd
self.terrestrial_search_container.execute(cmd)
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)
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.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))
+ 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]
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 \
- (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):
- #("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,
"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,
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)
- 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)
- 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
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_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")),
(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_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"),
(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))
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
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):
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]
- 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
+ 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
+
+ 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,
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.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]
plpid = self.scan_ter.plp_id.value)
removeAll = False
elif self.scan_typeterrestrial.value == "complete":
- getInitialTerrestrialTransponderList(tlist, nimmanager.getTerrestrialDescription(index_to_scan))
+ skip_t2 = True
if nim.isCompatible("DVB-T2"):
- action = SEARCH_TERRESTRIAL2_TRANSPONDERS
+ scan_util = len(self.terrestrialTransponderGetCmd(nim.slot)) and True or False
+ if scan_util:
+ action = SEARCH_TERRESTRIAL2_TRANSPONDERS
+ else:
+ skip_t2 = False
+
+ getInitialTerrestrialTransponderList(tlist, nimmanager.getTerrestrialDescription(index_to_scan), skip_t2)
flags = self.scan_networkScan.value and eComponentScan.scanNetworkSearch or 0
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 = [ ]
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 = 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 "DVB-T2" in known_networks: # we need to remove "DVB-T" when networks have "DVB-T2"
nims_dvb_t = []
for nim in nims_to_scan:
- if nim.type == "DVB-T":
+ if nim.getType() == "DVB-T":
nims_dvb_t.append(nim)
for nim in nims_dvb_t:
else:
action = SEARCH_CABLE_TRANSPONDERS
elif nim.isCompatible("DVB-T"):
- getInitialTerrestrialTransponderList(tlist, nimmanager.getTerrestrialDescription(nim.slot))
+ skip_t2 = True
if nim.isCompatible("DVB-T2"):
- action = SEARCH_TERRESTRIAL2_TRANSPONDERS
+ scan_util = len(self.terrestrialTransponderGetCmd(nim.slot)) and True or False
+ if scan_util:
+ action = SEARCH_TERRESTRIAL2_TRANSPONDERS
+ else:
+ skip_t2 = False
+ getInitialTerrestrialTransponderList(tlist, nimmanager.getTerrestrialDescription(nim.slot), skip_t2)
else:
assert False
projects / vuplus_dvbapp / blobdiff