def __init__(self, session, feid):
self.initcomplete = False
self.feid = feid
self.oldref = None
self.frontendData = None
service = session and session.nav.getCurrentService()
feinfo = service and service.frontendInfo()
self.frontendData = feinfo and feinfo.getAll(True)
del feinfo
del service
if not self.openFrontend():
self.oldref = session.nav.getCurrentlyPlayingServiceReference()
session.nav.stopService() # try to disable foreground service
if not self.openFrontend():
if session.pipshown: # try to disable pip
session.pipshown = False
del session.pip
if not self.openFrontend():
self.frontend = None # in normal case this should not happen
ScanSetup.__init__(self, session)
Screen.setTitle(self, _("Satfinder"))
self.tuner = Tuner(self.frontend)
self["introduction"].setText("")
self["Frontend"] = FrontendStatus(
frontend_source=lambda: self.frontend, update_interval=100)
self.initcomplete = True
self.onClose.append(self.__onClose)
def TunerTypeChanged(self):
fe_id = int(self.scan_nims.value)
multiType = config.Nims[fe_id].multiType
system = multiType.getText()
if (system in ('DVB-S', 'DVB-S2') and config.Nims[fe_id].dvbs.configMode.value == "nothing") or \
(system in ('DVB-T', 'DVB-T2') and config.Nims[fe_id].dvbt.configMode.value == "nothing") or \
(system in ('DVB-C') and config.Nims[fe_id].dvbc.configMode.value == "nothing") or \
(system in ('ATSC') and config.Nims[fe_id].atsc.configMode.value == "nothing"):
return
slot = nimmanager.nim_slots[fe_id]
print("dvb_api_version ", iDVBFrontend.dvb_api_version)
self.frontend = None
if not self.openFrontend():
self.session.nav.stopService()
if not self.openFrontend():
if self.session.pipshown:
from Screens.InfoBar import InfoBar
InfoBar.instance and hasattr(InfoBar.instance, "showPiP") and InfoBar.instance.showPiP()
if not self.openFrontend():
self.frontend = None # in normal case this should not happen
self.tuner = Tuner(self.frontend)
if slot.isMultiType():
eDVBResourceManager.getInstance().setFrontendType(slot.frontend_id, "dummy", False) #to force a clear of m_delsys_whitelist
types = slot.getMultiTypeList()
import six
for FeType in six.itervalues(types):
if FeType in ("DVB-S", "DVB-S2", "DVB-S2X") and config.Nims[slot.slot].dvbs.configMode.value == "nothing":
continue
elif FeType in ("DVB-T", "DVB-T2") and config.Nims[slot.slot].dvbt.configMode.value == "nothing":
continue
elif FeType in ("DVB-C", "DVB-C2") and config.Nims[slot.slot].dvbc.configMode.value == "nothing":
continue
elif FeType in ("ATSC") and config.Nims[slot.slot].atsc.configMode.value == "nothing":
continue
eDVBResourceManager.getInstance().setFrontendType(slot.frontend_id, FeType, True)
else:
eDVBResourceManager.getInstance().setFrontendType(slot.frontend_id, slot.getType())
# if not path.exists("/proc/stb/frontend/%d/mode" % fe_id) and iDVBFrontend.dvb_api_version >= 5:
print("api >=5 and new style tuner driver")
if self.frontend:
if system == 'DVB-C':
ret = self.frontend.changeType(iDVBFrontend.feCable)
elif system in ('DVB-T', 'DVB-T2'):
ret = self.frontend.changeType(iDVBFrontend.feTerrestrial)
elif system in ('DVB-S', 'DVB-S2'):
ret = self.frontend.changeType(iDVBFrontend.feSatellite)
elif system == 'ATSC':
ret = self.frontend.changeType(iDVBFrontend.feATSC)
else:
ret = False
if not ret:
print("%d: tunerTypeChange to '%s' failed" % (fe_id, system))
else:
print("new system ", system)
else:
print("%d: tunerTypeChange to '%s' failed (BUSY)" % (fe_id, multiType.getText()))
self.retune()
def prepareScanData(self, orb, pol, band, is_scan):
self.is_runable = False
self.orb_position = orb[0]
self.feid = int(self.scan_nims.value)
tab_hilow = {"high" : 1, "low" : 0}
tab_pol = {
"horizontal" : eDVBFrontendParametersSatellite.Polarisation_Horizontal,
"vertical" : eDVBFrontendParametersSatellite.Polarisation_Vertical,
"circular left" : eDVBFrontendParametersSatellite.Polarisation_CircularLeft,
"circular right" : eDVBFrontendParametersSatellite.Polarisation_CircularRight
}
returnvalue = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
if not self.openFrontend():
self.oldref = self.session.nav.getCurrentlyPlayingServiceReference()
self.session.nav.stopService()
if not self.openFrontend():
if self.session.pipshown:
self.session.pipshown = False
del self.session.pip
if not self.openFrontend():
self.frontend = None
self.tuner = Tuner(self.frontend)
if tab_hilow[band]:
self.scan_sat.frequency.value = 12515
else:
self.scan_sat.frequency.value = 11015
returnvalue = (self.scan_sat.frequency.value,
0,
tab_pol[pol],
0,
0,
orb[0],
eDVBFrontendParametersSatellite.System_DVB_S,
0,
0,
0)
self.tuner.tune(returnvalue)
if self.getNimSocket(self.feid) < 0:
print "can't find i2c number!!"
return
try:
cmd = "%s %d %d %d %d %d %d %d %d" % (self.binName, self.blindscan_start_frequency.value/1000000, self.blindscan_stop_frequency.value/1000000, self.blindscan_start_symbol.value/1000000, self.blindscan_stop_symbol.value/1000000, tab_pol[pol], tab_hilow[band], self.feid, self.getNimSocket(self.feid))
except: return
print "prepared command : [%s]" % (cmd)
self.blindscan_container = eConsoleAppContainer()
self.blindscan_container.appClosed.append(self.blindscanContainerClose)
self.blindscan_container.dataAvail.append(self.blindscanContainerAvail)
self.blindscan_container.execute(cmd)
tmpstr = "Look for available transponders.\nThis works will take several minutes.\n\n - Current Status : %d/%d\n - Orbital Positions : %s\n - Polarization : %s\n - Bandwidth : %s" %(self.running_count, self.max_count, orb[1], pol, band)
if is_scan :
self.blindscan_session = self.session.openWithCallback(self.blindscanSessionClose, MessageBox, _(tmpstr), MessageBox.TYPE_INFO)
else:
self.blindscan_session = self.session.openWithCallback(self.blindscanSessionNone, MessageBox, _(tmpstr), MessageBox.TYPE_INFO)
def statusCallback(self):
if self.state == 0:
if self.port_index == 0:
self.clearNimEntries()
config.Nims[self.feid].dvbs.diseqcA.value = "%d" % (
self.sat_frequencies[self.index][self.SAT_TABLE_ORBPOS])
elif self.port_index == 1:
self.clearNimEntries()
config.Nims[self.feid].dvbs.diseqcB.value = "%d" % (
self.sat_frequencies[self.index][self.SAT_TABLE_ORBPOS])
elif self.port_index == 2:
self.clearNimEntries()
config.Nims[self.feid].dvbs.diseqcC.value = "%d" % (
self.sat_frequencies[self.index][self.SAT_TABLE_ORBPOS])
elif self.port_index == 3:
self.clearNimEntries()
config.Nims[self.feid].dvbs.diseqcD.value = "%d" % (
self.sat_frequencies[self.index][self.SAT_TABLE_ORBPOS])
if self.nr_of_ports == 4:
config.Nims[self.feid].dvbs.diseqcMode.value = "diseqc_a_b_c_d"
elif self.nr_of_ports == 2:
config.Nims[self.feid].dvbs.diseqcMode.value = "diseqc_a_b"
else:
config.Nims[self.feid].dvbs.diseqcMode.value = "single"
config.Nims[self.feid].dvbs.configMode.value = "simple"
config.Nims[
self.feid].dvbs.simpleDiSEqCSetVoltageTone = self.simple_tone
config.Nims[
self.
feid].dvbs.simpleDiSEqCOnlyOnSatChange = self.simple_sat_change
self.saveAndReloadNimConfig()
self.state += 1
elif self.state == 1:
InitNimManager(nimmanager)
self.tuner = Tuner(self.frontend)
if self.raw_channel:
self.raw_channel.requestTsidOnid()
self.tuner.tune(self.sat_frequencies[self.index])
self["statusbar"].setText(
_("Checking tuner %d\nDiSEqC port %s for %s") %
(self.feid, self.diseqc_ports[self.port_index],
self.sat_frequencies[self.index][self.SAT_TABLE_NAME]))
self["tunerstatusbar"].setText(" ")
self.count = 0
self.state = 0
self.startTunerStatusTimer()
return
self.startStatusTimer()
def __onShow(self):
if self.oldref is not None:
self.session.nav.stopService() # try to disable foreground service
if not self.openFrontend():
if self.session.pipshown: # try to disable pip
self.session.pipshown = False
del self.session.pip
if not self.openFrontend():
self.frontend = None # in normal case this should not happen
self.tuner = Tuner(self.frontend)
self.retune(None)
def prepareFrontend(self): self.frontend = None if not self.openFrontend(): self.session.nav.stopService() if not self.openFrontend(): if self.session.pipshown: from Screens.InfoBar import InfoBar InfoBar.instance and hasattr(InfoBar.instance, "showPiP") and InfoBar.instance.showPiP() if not self.openFrontend(): self.frontend = None # in normal case this should not happen self.tuner = Tuner(self.frontend) self.retune()
def prepareFrontend(self): self.frontend = None if not self.openFrontend(): self.session.nav.stopService() if not self.openFrontend(): if self.session.pipshown: # try to disable pip self.session.pipshown = False del self.session.pip if not self.openFrontend(): self.frontend = None # in normal case this should not happen self.tuner = Tuner(self.frontend) self.retune(None)
def prepareFrontend(self):
self.frontend = None
if not self.openFrontend():
self.session.nav.stopService()
if not self.openFrontend():
if self.session.pipshown:
self.session.pipshown = False
del self.session.pip
if not self.openFrontend():
self.frontend = None
self.tuner = Tuner(self.frontend)
self.retune(None)
def prepareFrontend(self):
self.frontend = None
if not self.openFrontend():
self.session.nav.stopService()
if not self.openFrontend():
if self.session.pipshown:
from Screens.InfoBar import InfoBar
InfoBar.instance and hasattr(
InfoBar.instance,
'showPiP') and InfoBar.instance.showPiP()
if not self.openFrontend():
self.frontend = None
self.tuner = Tuner(self.frontend)
self.retune(None)
def initFrontend(self):
if self.oldref is None:
self.oldref = self.session.nav.getCurrentlyPlayingServiceReference(
)
if not self.openFrontend():
self.prev_ref = True
self.session.nav.stopService() # try to disable foreground service
if not self.openFrontend():
if self.session.pipshown: # try to disable pip
self.session.pipshown = False
del self.session.pip
if not self.openFrontend():
self.frontend = None # in normal case this should not happen
self.tuner = Tuner(self.frontend)
def initFrontend(self):
if self.oldref is None:
self.oldref = self.session.nav.getCurrentlyPlayingServiceReference(
)
if not self.openFrontend():
self.prev_ref = True
self.session.nav.stopService()
if not self.openFrontend():
if self.session.pipshown:
self.session.pipshown = False
del self.session.pip
if not self.openFrontend():
self.frontend = None
self.tuner = Tuner(self.frontend)
self.retune(None)
def prepareFrontend(self):
self.frontend = None
if not self.openFrontend():
self.session.nav.stopService()
if not self.openFrontend():
if self.session.pipshown:
from Screens.InfoBar import InfoBar
InfoBar.instance and hasattr(InfoBar.instance, "showPiP") and InfoBar.instance.showPiP()
if not self.openFrontend():
self.frontend = None # in normal case this should not happen
self.tuner = Tuner(self.frontend)
if nimmanager.nim_slots[int(self.satfinder_scan_nims.value)].isCompatible("DVB-S"):
self.updatePreDefTransponders()
self.createSetup()
self.retune()
def prepareFrontend(self):
self.frontend = None
if not self.openFrontend():
self.session.nav.stopService()
if not self.openFrontend():
if self.session.pipshown: # try to disable pip
if hasattr(self.session, 'infobar'):
if self.session.infobar.servicelist.dopipzap:
self.session.infobar.servicelist.togglePipzap()
if hasattr(self.session, 'pip'):
del self.session.pip
self.session.pipshown = False
if not self.openFrontend():
self.frontend = None # in normal case this should not happen
self.tuner = Tuner(self.frontend)
self.retune(None)
def prepareFrontend(self):
self.frontend = None
if hasattr(self, 'raw_channel'):
del self.raw_channel
if not self.openFrontend():
self.oldref = self.session.nav.getCurrentlyPlayingServiceReference()
self.session.nav.stopService()
if not self.openFrontend():
if self.session.pipshown:
self.session.pipshown = False
del self.session.pip
self.openFrontend()
if self.frontend == None :
self.session.open(MessageBox, _("Sorry, this tuner is in use."), MessageBox.TYPE_ERROR)
return False
self.tuner = Tuner(self.frontend)
return True
def TunerTypeChanged(self):
fe_id = int(self.scan_nims.value)
multiType = config.Nims[fe_id].multiType
system = multiType.getText()
if (system in ('DVB-S','DVB-S2') and config.Nims[fe_id].dvbs.configMode.value == "nothing") or \
(system in ('DVB-T','DVB-T2') and config.Nims[fe_id].dvbt.configMode.value == "nothing") or \
(system in ('DVB-C') and config.Nims[fe_id].dvbc.configMode.value == "nothing"):
self.createSetup()
return
nim = nimmanager.nim_slots[fe_id]
print "dvb_api_version ", iDVBFrontend.dvb_api_version
self.frontend = None
if not self.openFrontend():
self.session.nav.stopService()
if not self.openFrontend():
if self.session.pipshown:
from Screens.InfoBar import InfoBar
InfoBar.instance and hasattr(
InfoBar.instance,
"showPiP") and InfoBar.instance.showPiP()
if not self.openFrontend():
self.frontend = None # in normal case this should not happen
self.tuner = Tuner(self.frontend)
eDVBResourceManager.getInstance().setFrontendType(
nim.frontend_id, nim.getType())
# if not path.exists("/proc/stb/frontend/%d/mode" % fe_id) and iDVBFrontend.dvb_api_version >= 5:
print "api >=5 and new style tuner driver"
if self.frontend:
if system == 'DVB-C':
ret = self.frontend.changeType(iDVBFrontend.feCable)
elif system in ('DVB-T', 'DVB-T2'):
ret = self.frontend.changeType(iDVBFrontend.feTerrestrial)
elif system in ('DVB-S', 'DVB-S2'):
ret = self.frontend.changeType(iDVBFrontend.feSatellite)
elif system == 'ATSC':
ret = self.frontend.changeType(iDVBFrontend.feATSC)
else:
ret = False
if not ret:
print "%d: tunerTypeChange to '%s' failed" % (fe_id, system)
else:
print "new system ", system
else:
print "%d: tunerTypeChange to '%s' failed (BUSY)" % (
fe_id, multiType.getText())
self.createSetup()
def initFrontend(self):
if self.oldref is None:
self.oldref = self.session.nav.getCurrentlyPlayingServiceReference(
)
if not self.openFrontend():
self.prev_ref = True
self.session.nav.stopService() # try to disable foreground service
if not self.openFrontend():
if self.session.pipshown: # try to disable pip
self.session.pipshown = False
del self.session.pip
if not self.openFrontend():
self.frontend = None # in normal case this should not happen
try:
self.tuner = Tuner(self.frontend)
self["Frontend"] = FrontendStatus(
frontend_source=lambda: self.frontend, update_interval=100)
except:
pass
def keyGo(self):
selected_nim = int(self.SelectedNimToList(self.select_nim.value))
selected_position = self.positions_config_list[selected_nim].index
nim_positions_list = [
self.all_pos_per_dvbs_nim[int(
self.select_nim.value)][selected_position]
]
self.position = nim_positions_list[0][0]
self.position_name = nim_positions_list[0][1]
self.frontend = self.OpenFrontend()
if self.frontend is None:
self.oldref = self.session.nav.getCurrentlyPlayingServiceReference(
)
self.session.nav.stopService()
self.frontend = self.OpenFrontend()
if self.frontend is None:
print "*** cannot open frontend"
return
self.i2cbus = self.GetI2CBusFromSlot(int(self.select_nim.value))
if self.i2cbus < 0:
print "*** Can't find i2c bus for this nim"
return
#print "*** selected_nim =", selected_nim
#print "*** selected_position =", selected_position
#print "*** nim_positions_list =", nim_positions_list
#print "*** position =", self.PositionToString(self.position), "(", self.position, ")"
#print "*** position_name =", self.position_name
self.tuner = Tuner(self.frontend)
self.polarisation = self.PolarisationFirst()
self.lof = self.LOFFirst()
self.enigma_transponders = []
self.text_transponders = []
self.xml_transponders = []
self.status_screen = self.session.openWithCallback(
self.CallbackStatusScreenDone, SatscanStatus, self)
def __init__(self, session, feid):
self.initcomplete = False
self.feid = feid
self.oldref = None
if not self.openFrontend():
self.oldref = session.nav.getCurrentlyPlayingServiceReference()
session.nav.stopService() # try to disable foreground service
if not self.openFrontend():
if session.pipshown: # try to disable pip
session.pipshown = False
session.deleteDialog(session.pip)
del session.pip
if not self.openFrontend():
self.frontend = None # in normal case this should not happen
ScanSetup.__init__(self, session, 'S')
self.tuner = Tuner(self.frontend)
self["introduction"].setText("")
self["Frontend"] = FrontendStatus(frontend_source = lambda : self.frontend, update_interval = 100)
self.initcomplete = True
self.onClose.append(self.__onClose)
def TunerTypeChanged(self):
fe_id = int(self.scan_nims.value)
multiType = config.Nims[fe_id].multiType
system = multiType.getText()
if system in (
'DVB-S', 'DVB-S2'
) and config.Nims[fe_id].dvbs.configMode.value == 'nothing' or system in (
'DVB-T', 'DVB-T2'
) and config.Nims[
fe_id].dvbt.configMode.value == 'nothing' or system in 'DVB-C' and config.Nims[
fe_id].dvbc.configMode.value == 'nothing' or system in 'ATSC' and config.Nims[
fe_id].atsc.configMode.value == 'nothing':
return
else:
slot = nimmanager.nim_slots[fe_id]
print 'dvb_api_version ', iDVBFrontend.dvb_api_version
self.frontend = None
if not self.openFrontend():
self.session.nav.stopService()
if not self.openFrontend():
if self.session.pipshown:
from Screens.InfoBar import InfoBar
InfoBar.instance and hasattr(
InfoBar.instance,
'showPiP') and InfoBar.instance.showPiP()
if not self.openFrontend():
self.frontend = None
self.tuner = Tuner(self.frontend)
if slot.isMultiType():
eDVBResourceManager.getInstance().setFrontendType(
slot.frontend_id, 'dummy', False)
types = slot.getMultiTypeList()
for FeType in types.itervalues():
if FeType in (
'DVB-S', 'DVB-S2', 'DVB-S2X') and config.Nims[
slot.slot].dvbs.configMode.value == 'nothing':
continue
elif FeType in ('DVB-T', 'DVB-T2') and config.Nims[
slot.slot].dvbt.configMode.value == 'nothing':
continue
elif FeType in ('DVB-C', 'DVB-C2') and config.Nims[
slot.slot].dvbc.configMode.value == 'nothing':
continue
elif FeType in 'ATSC' and config.Nims[
slot.slot].atsc.configMode.value == 'nothing':
continue
eDVBResourceManager.getInstance().setFrontendType(
slot.frontend_id, FeType, True)
else:
eDVBResourceManager.getInstance().setFrontendType(
slot.frontend_id, slot.getType())
print 'api >=5 and new style tuner driver'
if self.frontend:
if system == 'DVB-C':
ret = self.frontend.changeType(iDVBFrontend.feCable)
elif system in ('DVB-T', 'DVB-T2'):
ret = self.frontend.changeType(iDVBFrontend.feTerrestrial)
elif system in ('DVB-S', 'DVB-S2'):
ret = self.frontend.changeType(iDVBFrontend.feSatellite)
elif system == 'ATSC':
ret = self.frontend.changeType(iDVBFrontend.feATSC)
else:
ret = False
if not ret:
print "%d: tunerTypeChange to '%s' failed" % (fe_id,
system)
else:
print 'new system ', system
else:
print "%d: tunerTypeChange to '%s' failed (BUSY)" % (
fe_id, multiType.getText())
return
def prepareScanData(self, orb, pol, band, is_scan):
self.is_runable = False
self.orb_position = orb[0]
self.sat_name = orb[1]
self.feid = int(self.scan_nims.value)
tab_hilow = {"high": 1, "low": 0}
tab_pol = {
"horizontal":
eDVBFrontendParametersSatellite.Polarisation_Horizontal,
"vertical":
eDVBFrontendParametersSatellite.Polarisation_Vertical,
"circular left":
eDVBFrontendParametersSatellite.Polarisation_CircularLeft,
"circular right":
eDVBFrontendParametersSatellite.Polarisation_CircularRight
}
returnvalue = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
self.frontend = None
if not self.openFrontend():
self.oldref = self.session.nav.getCurrentlyPlayingServiceReference(
)
self.session.nav.stopService()
if not self.openFrontend():
if self.session.pipshown:
self.session.pipshown = False
del self.session.pip
self.openFrontend()
if self.frontend == None:
self.session.open(MessageBox, _("Sorry, this tuner is in use."),
MessageBox.TYPE_ERROR)
return False
self.tuner = Tuner(self.frontend)
if self.is_c_band_scan:
self.scan_sat.frequency.value = 3600
else:
if tab_hilow[band]:
self.scan_sat.frequency.value = 12515
else:
self.scan_sat.frequency.value = 11015
returnvalue = (self.scan_sat.frequency.value, 0, tab_pol[pol], 0, 0,
orb[0], eDVBFrontendParametersSatellite.System_DVB_S, 0,
0, 0)
self.tuner.tune(returnvalue)
if self.getNimSocket(self.feid) < 0:
print "can't find i2c number!!"
return
c_band_loc_osc = 5150
uni_lnb_loc_osc = {"high": 10600, "low": 9750}
uni_lnb_cutoff = 11700
if self.is_c_band_scan:
temp_start_int_freq = c_band_loc_osc - self.blindscan_stop_frequency.value
temp_end_int_freq = c_band_loc_osc - self.blindscan_start_frequency.value
status_box_start_freq = c_band_loc_osc - temp_end_int_freq
status_box_end_freq = c_band_loc_osc - temp_start_int_freq
else:
if tab_hilow[band]:
if self.blindscan_start_frequency.value < uni_lnb_cutoff:
temp_start_int_freq = uni_lnb_cutoff - uni_lnb_loc_osc[band]
else:
temp_start_int_freq = self.blindscan_start_frequency.value - uni_lnb_loc_osc[
band]
temp_end_int_freq = self.blindscan_stop_frequency.value - uni_lnb_loc_osc[
band]
else:
if self.blindscan_stop_frequency.value > uni_lnb_cutoff:
temp_end_int_freq = uni_lnb_cutoff - uni_lnb_loc_osc[band]
else:
temp_end_int_freq = self.blindscan_stop_frequency.value - uni_lnb_loc_osc[
band]
temp_start_int_freq = self.blindscan_start_frequency.value - uni_lnb_loc_osc[
band]
status_box_start_freq = temp_start_int_freq + uni_lnb_loc_osc[band]
status_box_end_freq = temp_end_int_freq + uni_lnb_loc_osc[band]
if config.misc.boxtype.value.startswith('vu'):
cmd = "vuplus_blindscan %d %d %d %d %d %d %d %d" % (
temp_start_int_freq, temp_end_int_freq,
self.blindscan_start_symbol.value,
self.blindscan_stop_symbol.value, tab_pol[pol],
tab_hilow[band], self.feid, self.getNimSocket(self.feid)
) # commented out by Huevos cmd = "vuplus_blindscan %d %d %d %d %d %d %d %d" % (self.blindscan_start_frequency.value/1000000, self.blindscan_stop_frequency.value/1000000, self.blindscan_start_symbol.value, self.blindscan_stop_symbol.value, tab_pol[pol], tab_hilow[band], self.feid, self.getNimSocket(self.feid))
elif config.misc.boxtype.value.startswith('et'):
cmd = "avl_xtrend_blindscan %d %d %d %d %d %d %d %d" % (
temp_start_int_freq, temp_end_int_freq,
self.blindscan_start_symbol.value,
self.blindscan_stop_symbol.value, tab_pol[pol],
tab_hilow[band], self.feid, self.getNimSocket(self.feid)
) # commented out by Huevos cmd = "avl_xtrend_blindscan %d %d %d %d %d %d %d %d" % (self.blindscan_start_frequency.value/1000000, self.blindscan_stop_frequency.value/1000000, self.blindscan_start_symbol.value, self.blindscan_stop_symbol.value, tab_pol[pol], tab_hilow[band], self.feid, self.getNimSocket(self.feid))
print "prepared command : [%s]" % (cmd)
self.thisRun = [
] # used to check result corresponds with values used above
self.thisRun.append(int(temp_start_int_freq))
self.thisRun.append(int(temp_end_int_freq))
self.thisRun.append(int(tab_hilow[band]))
self.blindscan_container = eConsoleAppContainer()
self.blindscan_container.appClosed.append(self.blindscanContainerClose)
self.blindscan_container.dataAvail.append(self.blindscanContainerAvail)
self.blindscan_container.execute(cmd)
display_pol = pol # Display the correct polarisation in the MessageBox below
if self.scan_sat.polarization.value == eDVBFrontendParametersSatellite.Polarisation_CircularRight:
display_pol = _("circular right")
elif self.scan_sat.polarization.value == eDVBFrontendParametersSatellite.Polarisation_CircularLeft:
display_pol = _("circular left")
elif self.scan_sat.polarization.value == eDVBFrontendParametersSatellite.Polarisation_CircularRight + 2:
if pol == "horizontal":
display_pol = _("circular left")
else:
display_pol = _("circular right")
tmpstr = _(
"Looking for available transponders.\nThis will take a short while.\n\n Current Status : %d/%d\n Satellite : %s\n Polarization : %s\n Frequency range : %d - %d MHz\n Symbol rates : %d - %d MHz"
) % (self.running_count, self.max_count, orb[1], display_pol,
status_box_start_freq, status_box_end_freq,
self.blindscan_start_symbol.value,
self.blindscan_stop_symbol.value)
if is_scan:
self.blindscan_session = self.session.openWithCallback(
self.blindscanSessionClose, MessageBox, tmpstr,
MessageBox.TYPE_INFO)
else:
self.blindscan_session = self.session.openWithCallback(
self.blindscanSessionNone, MessageBox, tmpstr,
MessageBox.TYPE_INFO)
def statusCallback(self):
if self.state == 0:
if self.port_index == 0 and self.diseqc[0] == "3600":
self.clearNimEntries()
config.Nims[self.feid].diseqcA.value = "%d" % (
self.sat_frequencies[self.index][self.SAT_TABLE_ORBPOS])
elif self.port_index == 1 and self.diseqc[1] == "3600":
self.clearNimEntries()
config.Nims[self.feid].diseqcB.value = "%d" % (
self.sat_frequencies[self.index][self.SAT_TABLE_ORBPOS])
elif self.port_index == 2 and self.diseqc[2] == "3600":
self.clearNimEntries()
config.Nims[self.feid].diseqcC.value = "%d" % (
self.sat_frequencies[self.index][self.SAT_TABLE_ORBPOS])
elif self.port_index == 3 and self.diseqc[3] == "3600":
self.clearNimEntries()
config.Nims[self.feid].diseqcD.value = "%d" % (
self.sat_frequencies[self.index][self.SAT_TABLE_ORBPOS])
if self.nr_of_ports == 4:
config.Nims[self.feid].diseqcMode.value = "diseqc_a_b_c_d"
elif self.nr_of_ports == 2:
config.Nims[self.feid].diseqcMode.value = "diseqc_a_b"
else:
config.Nims[self.feid].diseqcMode.value = "single"
if self.sat_frequencies[self.index][
self.SAT_TABLE_ORBPOS] == 360 and not self.found_sats:
config.Nims[
self.feid].simpleDiSEqCSetCircularLNB.value = True
self.circular_setup = True
config.Nims[self.feid].configMode.value = "simple"
config.Nims[
self.feid].simpleDiSEqCSetVoltageTone = self.simple_tone
config.Nims[
self.feid].simpleDiSEqCOnlyOnSatChange = self.simple_sat_change
self.saveAndReloadNimConfig()
self.state += 1
elif self.state == 1:
if self.diseqc[self.port_index] != "3600":
self.statusTimer.stop()
self.count = 0
self.state = 0
self.index = len(self.sat_frequencies) - 1
self.tunerStopScan(False)
return
if self.circular_setup:
if self.raw_channel:
self.raw_channel.receivedTsidOnid.get().remove(
self.gotTsidOnid)
del self.frontend
del self.raw_channel
if not self.openFrontend():
self.frontend = None
self.raw_channel = None
if self.raw_channel:
self.raw_channel.receivedTsidOnid.get().append(
self.gotTsidOnid)
InitNimManager(nimmanager)
self.tuner = Tuner(self.frontend)
if self.raw_channel:
self.raw_channel.requestTsidOnid()
self.tuner.tune(self.sat_frequencies[self.index])
self["statusbar"].setText(
_("Checking tuner %s\nDiSEqC port %s for %s") %
(chr(self.feid + 65), self.diseqc_ports[self.port_index],
self.sat_frequencies[self.index][self.SAT_TABLE_NAME]))
self["tunerstatusbar"].setText(" ")
self.count = 0
self.state = 0
self.startTunerStatusTimer()
return
self.startStatusTimer()
def __init__(self, session, feid):
self.skin = PositionerSetup.skin
Screen.__init__(self, session)
self.feid = feid
self.oldref = None
cur = {}
if not self.openFrontend():
self.oldref = session.nav.getCurrentlyPlayingServiceReference()
service = session.nav.getCurrentService()
feInfo = service and service.frontendInfo()
if feInfo:
cur = feInfo.getTransponderData(True)
del feInfo
del service
session.nav.stopService() # try to disable foreground service
if not self.openFrontend():
if session.pipshown: # try to disable pip
service = self.session.pip.pipservice
feInfo = service and service.frontendInfo()
if feInfo:
cur = feInfo.getTransponderData()
del feInfo
del service
session.pipshown = False
del session.pip
if not self.openFrontend():
self.frontend = None # in normal case this should not happen
self.frontendStatus = {}
self.diseqc = Diseqc(self.frontend)
self.tuner = Tuner(self.frontend)
tp = (cur.get("frequency", 0) / 1000, cur.get("symbol_rate", 0) / 1000,
cur.get("polarization",
eDVBFrontendParametersSatellite.Polarisation_Horizontal),
cur.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto),
cur.get("inversion",
eDVBFrontendParametersSatellite.Inversion_Unknown),
cur.get("orbital_position", 0),
cur.get("system", eDVBFrontendParametersSatellite.System_DVB_S),
cur.get("modulation",
eDVBFrontendParametersSatellite.Modulation_QPSK),
cur.get("rolloff",
eDVBFrontendParametersSatellite.RollOff_alpha_0_35),
cur.get("pilot", eDVBFrontendParametersSatellite.Pilot_Unknown))
self.tuner.tune(tp)
self.createConfig()
self.isMoving = False
self.stopOnLock = False
self.red = Label("")
self["red"] = self.red
self.green = Label("")
self["green"] = self.green
self.yellow = Label("")
self["yellow"] = self.yellow
self.blue = Label("")
self["blue"] = self.blue
self.list = []
self["list"] = ConfigList(self.list)
self.createSetup()
self["snr_db"] = TunerInfo(TunerInfo.SNR_DB,
statusDict=self.frontendStatus)
self["snr_percentage"] = TunerInfo(TunerInfo.SNR_PERCENTAGE,
statusDict=self.frontendStatus)
self["ber_value"] = TunerInfo(TunerInfo.BER_VALUE,
statusDict=self.frontendStatus)
self["snr_bar"] = TunerInfo(TunerInfo.SNR_BAR,
statusDict=self.frontendStatus)
self["ber_bar"] = TunerInfo(TunerInfo.BER_BAR,
statusDict=self.frontendStatus)
self["lock_state"] = TunerInfo(TunerInfo.LOCK_STATE,
statusDict=self.frontendStatus)
self["frequency_value"] = Label("")
self["symbolrate_value"] = Label("")
self["fec_value"] = Label("")
self["actions"] = ActionMap(
["DirectionActions", "OkCancelActions", "ColorActions"], {
"ok": self.go,
"cancel": self.keyCancel,
"up": self.up,
"down": self.down,
"left": self.left,
"right": self.right,
"red": self.redKey,
"green": self.greenKey,
"yellow": self.yellowKey,
"blue": self.blueKey,
}, -1)
self.updateColors("tune")
self.statusTimer = eTimer()
self.statusTimer.callback.append(self.updateStatus)
self.statusTimer.start(50, True)
self.onClose.append(self.__onClose)
def __init__(self, session, feid):
self.session = session
Screen.__init__(self, session)
self.feid = feid
self.oldref = None
log.open(self.LOG_SIZE)
if config.Nims[self.feid].configMode.value == 'advanced':
self.advanced = True
self.advancedconfig = config.Nims[self.feid].advanced
self.advancedsats = self.advancedconfig.sat
self.availablesats = map(lambda x: x[0], nimmanager.getRotorSatListForNim(self.feid))
else:
self.advanced = False
cur = { }
if not self.openFrontend():
self.oldref = session.nav.getCurrentlyPlayingServiceReference()
service = session.nav.getCurrentService()
feInfo = service and service.frontendInfo()
if feInfo:
cur = feInfo.getTransponderData(True)
del feInfo
del service
session.nav.stopService() # try to disable foreground service
if not self.openFrontend():
if session.pipshown: # try to disable pip
service = self.session.pip.pipservice
feInfo = service and service.frontendInfo()
if feInfo:
cur = feInfo.getTransponderData(True)
del feInfo
del service
from Screens.InfoBar import InfoBar
InfoBar.instance and hasattr(InfoBar.instance, "showPiP") and InfoBar.instance.showPiP()
if not self.openFrontend():
self.frontend = None # in normal case this should not happen
if hasattr(self, 'raw_channel'):
del self.raw_channel
self.frontendStatus = { }
self.diseqc = Diseqc(self.frontend)
# True means we dont like that the normal sec stuff sends commands to the rotor!
self.tuner = Tuner(self.frontend, ignore_rotor = True)
tp = ( cur.get("frequency", 0) / 1000,
cur.get("symbol_rate", 0) / 1000,
cur.get("polarization", eDVBFrontendParametersSatellite.Polarisation_Horizontal),
cur.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto),
cur.get("inversion", eDVBFrontendParametersSatellite.Inversion_Unknown),
cur.get("orbital_position", 0),
cur.get("system", eDVBFrontendParametersSatellite.System_DVB_S),
cur.get("modulation", eDVBFrontendParametersSatellite.Modulation_QPSK),
cur.get("rolloff", eDVBFrontendParametersSatellite.RollOff_alpha_0_35),
cur.get("pilot", eDVBFrontendParametersSatellite.Pilot_Unknown))
self.tuner.tune(tp)
self.isMoving = False
self.stopOnLock = False
self.red = Button("")
self["key_red"] = self.red
self.green = Button("")
self["key_green"] = self.green
self.yellow = Button("")
self["key_yellow"] = self.yellow
self.blue = Button("")
self["key_blue"] = self.blue
self.list = []
self["list"] = ConfigList(self.list)
self["snr_db"] = TunerInfo(TunerInfo.SNR_DB, statusDict = self.frontendStatus)
self["snr_percentage"] = TunerInfo(TunerInfo.SNR_PERCENTAGE, statusDict = self.frontendStatus)
self["ber_value"] = TunerInfo(TunerInfo.BER_VALUE, statusDict = self.frontendStatus)
self["snr_bar"] = TunerInfo(TunerInfo.SNR_BAR, statusDict = self.frontendStatus)
self["ber_bar"] = TunerInfo(TunerInfo.BER_BAR, statusDict = self.frontendStatus)
self["lock_state"] = TunerInfo(TunerInfo.LOCK_STATE, statusDict = self.frontendStatus)
self["frequency_value"] = Label("")
self["symbolrate_value"] = Label("")
self["fec_value"] = Label("")
self["polarisation"] = Label("")
self["status_bar"] = Label("")
self.statusMsgTimeoutTicks = 0
self.statusMsgBlinking = False
self.statusMsgBlinkCount = 0
self.statusMsgBlinkRate = 500 / self.UPDATE_INTERVAL # milliseconds
self.tuningChangedTo(tp)
self["actions"] = NumberActionMap(["DirectionActions", "OkCancelActions", "ColorActions", "TimerEditActions", "InputActions"],
{
"ok": self.keyOK,
"cancel": self.keyCancel,
"up": self.keyUp,
"down": self.keyDown,
"left": self.keyLeft,
"right": self.keyRight,
"red": self.redKey,
"green": self.greenKey,
"yellow": self.yellowKey,
"blue": self.blueKey,
"log": self.showLog,
"1": self.keyNumberGlobal,
"2": self.keyNumberGlobal,
"3": self.keyNumberGlobal,
"4": self.keyNumberGlobal,
"5": self.keyNumberGlobal,
"6": self.keyNumberGlobal,
"7": self.keyNumberGlobal,
"8": self.keyNumberGlobal,
"9": self.keyNumberGlobal,
"0": self.keyNumberGlobal
}, -1)
self.updateColors("tune")
self.statusTimer = eTimer()
self.statusTimer.callback.append(self.updateStatus)
self.collectingStatistics = False
self.statusTimer.start(self.UPDATE_INTERVAL, True)
self.dataAvailable = Event()
self.onClose.append(self.__onClose)
self.createConfig()
self.createSetup()
