def __init__(self, session):
Screen.__init__(self, session)
self["CurrentService"] = CurrentService(session.nav)
self["Event_Now"] = EventInfo(session.nav, EventInfo.NOW)
self["Event_Next"] = EventInfo(session.nav, EventInfo.NEXT)
self["FrontendStatus"] = FrontendStatus(service_source=session.nav.getCurrentService)
self["FrontendInfo"] = FrontendInfo(navcore=session.nav)
self["VideoPicture"] = Source()
self["TunerInfo"] = TunerInfo()
self["RecordState"] = RecordState(session)
self["Standby"] = Boolean(fixed=False)
from Components.SystemInfo import SystemInfo
nr_leds = SystemInfo.get("NumFrontpanelLEDs", 0)
if nr_leds > 0:
combine = Combine(func=lambda s: {(False, False): 0, (False, True): 1, (True, False): 2, (True, True): 3}[(s[0].boolean, s[1].boolean)])
combine.connect(self["Standby"])
combine.connect(self["RecordState"])
if nr_leds == 1:
FrontpanelLed(which=0, boolean=False, patterns=[PATTERN_OFF, PATTERN_BLINK, PATTERN_OFF, PATTERN_BLINK]).connect(combine)
elif nr_leds == 2:
FrontpanelLed(which=0, boolean=False, get_patterns=True).connect(combine)
FrontpanelLed(which=1, boolean=False, get_patterns=True).connect(combine)
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 __init__(self, session):
self.initcomplete = False
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
self.typeOfTuningEntry = None
self.systemEntry = None
self.satfinderTunerEntry = None
self.satEntry = None
ScanSetup.__init__(self, session)
self.setTitle(_('Satfinder'))
self['introduction'].setText(_('Press OK to scan'))
self['Frontend'] = FrontendStatus(
frontend_source=lambda: self.frontend, update_interval=100)
self['actions'] = ActionMap(['SetupActions'], {
'save': self.keyGoScan,
'ok': self.keyGoScan,
'cancel': self.keyCancel
}, -3)
self.initcomplete = True
self.session.postScanService = self.session.nav.getCurrentlyPlayingServiceOrGroup(
)
self.onClose.append(self.__onClose)
self.onShow.append(self.prepareFrontend)
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
ScanSetup.__init__(self, session)
self.setTitle(_("Satfinder"))
self["introduction"].setText(_("Press OK to scan"))
self["Frontend"] = FrontendStatus(
frontend_source=lambda: self.frontend, update_interval=100)
self["actions"] = ActionMap(
["SetupActions"], {
"save": self.keyGoScan,
"ok": self.keyGoScan,
"cancel": self.keyCancel,
}, -3)
self.initcomplete = True
self.oldref = self.session.nav.getCurrentlyPlayingServiceReference()
self.onClose.append(self.__onClose)
self.onShow.append(self.__onShow)
def __init__(self, session):
self.initcomplete = False
service = session and session.nav.getCurrentService()
feinfo = service and service.frontendInfo()
self.frontendData = feinfo and feinfo.getAll(True)
del feinfo
del service
self.typeOfTuningEntry = None
self.systemEntry = None
self.satfinderTunerEntry = None
self.satEntry = None
self.typeOfInputEntry = None
ScanSetup.__init__(self, session)
self.setTitle(_("Satfinder"))
self["introduction"].setText(_("Press OK to scan"))
self["Frontend"] = FrontendStatus(frontend_source = lambda : self.frontend, update_interval = 100)
self["actions"] = ActionMap(["SetupActions", "ColorActions"],
{
"save": self.keyGoScan,
"ok": self.keyGoScan,
"cancel": self.keyCancel,
}, -3)
self.initcomplete = True
self.session.postScanService = self.session.nav.getCurrentlyPlayingServiceOrGroup()
self.onClose.append(self.__onClose)
self.onShow.append(self.prepareFrontend)
def __init__(self, session):
self.skin = Dishpip.skin
Screen.__init__(self, session)
self["Dishpixmap"] = Boolean(fixed=True, poll=1500)
self["turnTime"] = Label("")
self["posFrom"] = Label("")
self["posGoto"] = Label("")
self["From"] = Label(_("From:"))
self["Goto"] = Label(_("Goto:"))
self["tunerName"] = Label("")
self["turnSpeed"] = Label("")
self.updateRotorSatList()
self.frontend = None
self["Frontend"] = FrontendStatus(service_source = lambda: self.frontend, update_interval=1000)
self.rotorTimer = eTimer()
self.rotorTimer.timeout.get().append(self.updateRotorMovingState)
self.turnTimer = eTimer()
self.turnTimer.callback.append(self.turnTimerLoop)
self.timeoutTimer = eTimer()
self.timeoutTimer.callback.append(self.__toHide)
self.rotor_pos = self.cur_orbpos = config.misc.lastrotorposition.value
config.misc.lastrotorposition.addNotifier(self.RotorpositionChange)
self.turn_time = self.total_time = None
self.close_timeout = self.moving_timeout = self.cur_polar = 0
self.__state = self.STATE_HIDDEN
self.onShow.append(self.__onShow)
self.onHide.append(self.__onHide)
def __init__(self, session):
Screen.__init__(self, session)
self["CurrentService"] = CurrentService(session.nav)
self["Event_Now"] = EventInfo(session.nav, EventInfo.NOW)
self["Event_Next"] = EventInfo(session.nav, EventInfo.NEXT)
self["FrontendStatus"] = FrontendStatus(
service_source=session.nav.getCurrentService)
self["FrontendInfo"] = FrontendInfo(navcore=session.nav)
self["VideoPicture"] = Source()
self["TunerInfo"] = TunerInfo()
self["RecordState"] = RecordState(session)
self["Standby"] = Boolean(fixed=False)
self["HddSleepingState"] = HddState(session)
from Components.SystemInfo import SystemInfo
combine = Combine(func=lambda s: {
(False, False): 0,
(False, True): 1,
(True, False): 2,
(True, True): 3
}[(s[0].boolean, s[1].boolean)])
combine.connect(self["Standby"])
combine.connect(self["RecordState"])
combine.connect(self["HddSleepingState"])
# | two leds | single led |
# recordstate standby red green
# false false off on off
# true false blnk on blnk
# false true on off off
# true true blnk off blnk
PATTERN_ON = (20, 0xffffffff, 0xffffffff)
PATTERN_OFF = (20, 0, 0)
PATTERN_BLINK = (20, 0x55555555, 0xa7fccf7a)
nr_leds = SystemInfo.get("NumFrontpanelLEDs", 0)
if nr_leds == 1:
FrontpanelLed(which=0,
boolean=False,
patterns=[
PATTERN_OFF, PATTERN_BLINK, PATTERN_OFF,
PATTERN_BLINK
]).connect(combine)
elif nr_leds == 2:
FrontpanelLed(which=0,
boolean=False,
patterns=[
PATTERN_OFF, PATTERN_BLINK, PATTERN_ON,
PATTERN_BLINK
]).connect(combine)
FrontpanelLed(
which=1,
boolean=False,
patterns=[PATTERN_ON, PATTERN_ON, PATTERN_OFF,
PATTERN_OFF]).connect(combine)
def __init__(self, session, args=0):
print "[MisPlsLcnScan][__init__] Starting..."
print "[MisPlsLcnScan][__init__] args", args
self.session = session
Screen.__init__(self, session)
Screen.setTitle(self, _("MIS/PLS LCN Scan"))
self["background"] = Pixmap()
self["action"] = Label(_("Starting scanner"))
self["status"] = Label("")
self["progress"] = ProgressBar()
self["progress_text"] = Progress()
self["actions"] = ActionMap(["SetupActions"], {
"cancel": self.keyCancel,
}, -2)
self.selectedNIM = -1
self.FTA_only = config.plugins.MisPlsLcnScan.onlyfree.value
self.networkid = 0
self.restrict_to_networkid = False
if args:
pass
self.frontend = None
self["Frontend"] = FrontendStatus(
frontend_source=lambda: self.frontend, update_interval=100)
self.rawchannel = None
self.session.postScanService = self.session.nav.getCurrentlyPlayingServiceOrGroup(
)
self.index = 0
self.LOCK_TIMEOUT_ROTOR = 1200 # 100ms for tick - 120 sec
self.LOCK_TIMEOUT_FIXED = 50 # 100ms for tick - 5 sec
self.path = "/etc/enigma2"
self.services_dict = {}
self.tmp_services_dict = {}
self.namespace_dict = {
} # to store namespace when sub network is enabled
self.logical_channel_number_dict = {}
self.ignore_visible_service_flag = False # make this a user override later if found necessary
self.VIDEO_ALLOWED_TYPES = [1, 4, 5, 17, 22, 24, 25, 27, 135]
self.AUDIO_ALLOWED_TYPES = [2, 10]
self.BOUQUET_PREFIX = "userbouquet.MisPlsLcnScan."
self.bouquetsIndexFilename = "bouquets.tv"
self.bouquetFilename = self.BOUQUET_PREFIX + config.plugins.MisPlsLcnScan.provider.value + ".tv"
self.bouquetName = PROVIDERS[config.plugins.MisPlsLcnScan.provider.
value]["name"] # already translated
self.namespace_complete = not (
config.usage.subnetwork.value
if hasattr(config.usage, "subnetwork") else True
) # config.usage.subnetwork not available in all images
self.LOCK_TIMEOUT = self.LOCK_TIMEOUT_FIXED
self.scanTransponders = self.getMisTransponders(
PROVIDERS[config.plugins.MisPlsLcnScan.provider.value]["orb_pos"])
self.transponders_correct_onid = []
self.onClose.append(self.__onClose)
self.onFirstExecBegin.append(self.firstExec)
def __init__(self, session):
self.skin = SimpleSatScan.skin
Screen.__init__(self, session)
self.initcomplete = False
self.frontend = None
self.prev_ref = False
self.oldref = None
self.updateSatList()
self.service = session and session.nav.getCurrentService()
self.feinfo = None
frontendData = None
if self.service is not None:
self.feinfo = self.service.frontendInfo()
frontendData = self.feinfo and self.feinfo.getAll(True)
self.createConfig(frontendData)
del self.feinfo
del self.service
self["Frontend"] = FrontendStatus(
frontend_source=lambda: self.frontend, update_interval=100)
self["actions"] = NumberActionMap(["SetupActions"], {
"ok": self.keyGo,
"cancel": self.keyCancel,
}, -2)
self.list = []
self.tpslist = []
self.tpslist_idx = 0
self.tuneTimer = eTimer()
self.tuneTimer.callback.append(self.updateTuneStatus)
ConfigListScreen.__init__(self, self.list)
if not self.scan_nims.value == "":
self.createSetup()
self.feid = int(self.scan_nims.value)
orbpos = "??"
if len(self.satList) > self.feid and len(
self.scan_satselection) > self.feid and len(
self.satList[self.feid]):
orbpos = self.OrbToStr(self.satList[self.feid][
self.scan_satselection[self.feid].index][0])
self["status"] = Label(
orbpos + ": " + str(self.scan_sat.frequency.value) + " " +
self.PolToStr(self.scan_sat.polarization.value))
self["introduction"] = Label(_("Press OK to start the scan."))
else:
self["introduction"] = Label(
_("Nothing to scan!\nPlease setup your tuner settings before you start a service scan."
))
self["status"] = Label("")
self.feid = None
self.initFrontend()
self.initcomplete = self.feid != None
def __init__(self,
session,
feid,
test_type=TEST_TYPE_QUICK,
loopsfailed=3,
loopssuccessful=1,
log=False):
Screen.__init__(self, session)
self.setup_title = _("DiSEqC Tester")
self.feid = feid
self.test_type = test_type
self.loopsfailed = loopsfailed
self.loopssuccessful = loopssuccessful
self.log = log
self["Overall_progress"] = Label(_("Overall progress:"))
self["Progress"] = Label(_("Progress:"))
self["Failed"] = Label(_("Failed:"))
self["Succeeded"] = Label(_("Succeeded:"))
self["Not_tested"] = Label(_("Not tested:"))
self["With_errors"] = Label(_("With errors:"))
self["actions"] = NumberActionMap(["SetupActions"], {
"ok": self.select,
"cancel": self.keyCancel,
}, -2)
TuneTest.__init__(self,
feid,
stopOnSuccess=self.loopssuccessful,
stopOnError=self.loopsfailed)
self["Frontend"] = FrontendStatus(
frontend_source=lambda: self.frontend, update_interval=100)
self["overall_progress"] = Progress()
self["sub_progress"] = Progress()
self["failed_counter"] = StaticText("0")
self["succeeded_counter"] = StaticText("0")
self["witherrors_counter"] = StaticText("0")
self["untestable_counter"] = StaticText("0")
self.list = []
self["progress_list"] = List(self.list)
self["progress_list"].onSelectionChanged.append(self.selectionChanged)
self["CmdText"] = StaticText(
_("Please wait while scanning is in progress..."))
self.indexlist = {}
self.readTransponderList()
self.running = False
self.results = {}
self.resultsstatus = {}
self.onLayoutFinish.append(self.go)
def __init__(self, session):
self.initcomplete = False
service = session and session.nav.getCurrentService()
feinfo = service and service.frontendInfo()
self.frontendData = feinfo and feinfo.getAll(True)
del feinfo
del service
self.typeOfTuningEntry = None
self.systemEntry = None
self.systemEntryATSC = None
self.satfinderTunerEntry = None
self.satEntry = None
self.typeOfInputEntry = None
self.DVB_TypeEntry = None
self.systemEntryTerr = None
self.preDefTransponderEntry = None
self.preDefTransponderCableEntry = None
self.preDefTransponderTerrEntry = None
self.preDefTransponderAtscEntry = None
self.frontend = None
self.is_id_boolEntry = None
# for reading stream
self.serviceList = []
ScanSetup.__init__(self, session)
self.setTitle(_("Signal Finder"))
self["introduction"].setText(_("Press OK to scan"))
self["Frontend"] = FrontendStatus(
frontend_source=lambda: self.frontend, update_interval=100)
self["key_red"] = StaticText("Close")
self["key_green"] = StaticText(_("Scan"))
self["key_yellow"] = StaticText("")
self["actions"] = ActionMap(
["SetupActions", "ColorActions"], {
"save": self.keyGoScan,
"ok": self.keyGoScan,
"cancel": self.keyCancel,
"yellow": self.keyReadServices,
}, -3)
# DVB stream info
self["tsid"] = StaticText("")
self["onid"] = StaticText("")
self["pos"] = StaticText("")
self.initcomplete = True
self.session.postScanService = self.session.nav.getCurrentlyPlayingServiceOrGroup(
)
self.session.nav.stopService()
self.onClose.append(self.__onClose)
self.onShow.append(self.prepareFrontend)
def newSessionGlobals__init__(self, session):
baseSessionGlobals__init__(self, session)
global SessionGlobals_instance
SessionGlobals_instance = self
from Components.Sources.CurrentService import CurrentService
from Components.Sources.EventInfo import EventInfo
from Components.Sources.FrontendStatus import FrontendStatus
from Components.Sources.FrontendInfo import FrontendInfo
from Components.Sources.Source import Source
from Components.Sources.TunerInfo import TunerInfo
from Components.Sources.Boolean import Boolean
from Components.Sources.RecordState import RecordState
from Components.Converter.Combine import Combine
from Components.Renderer.FrontpanelLed import FrontpanelLed
self["CurrentService"] = CurrentService(session.nav)
self["Event_Now"] = EventInfo(session.nav, EventInfo.NOW)
self["Event_Next"] = EventInfo(session.nav, EventInfo.NEXT)
self["FrontendStatus"] = FrontendStatus(service_source=session.nav.getCurrentService)
self["FrontendInfo"] = FrontendInfo(navcore=session.nav)
self["VideoPicture"] = Source()
self["TunerInfo"] = TunerInfo()
self["RecordState"] = RecordState(session)
self["Standby"] = Boolean(fixed=False)
from Components.SystemInfo import SystemInfo
combine = Combine(func=lambda s: {(False, False): 0, (False, True): 1, (True, False): 2, (True, True): 3}[(s[0].boolean, s[1].boolean)])
combine.connect(self["Standby"])
combine.connect(self["RecordState"])
# | two leds | single led |
# recordstate standby red green
# false false off on off
# true false blnk on blnk
# false true on off off
# true true blnk off blnk
PATTERN_ON = (20, 0xffffffff, 0xffffffff)
PATTERN_OFF = (20, 0, 0)
PATTERN_BLINK = (20, 0x55555555, 0xa7fccf7a)
nr_leds = SystemInfo.get("NumFrontpanelLEDs", 0)
if nr_leds == 1:
FrontpanelLed(which=0, boolean=False, patterns=[PATTERN_OFF, PATTERN_BLINK, PATTERN_OFF, PATTERN_BLINK]).connect(combine)
elif nr_leds == 2:
if config.plugins.VFD_spark.redLed.value == '1':
FrontpanelLed(which=0, boolean=False, patterns=[PATTERN_OFF, PATTERN_BLINK, PATTERN_ON, PATTERN_BLINK]).connect(combine)
if config.plugins.VFD_spark.greenLed.value == '1':
FrontpanelLed(which=1, boolean=False, patterns=[PATTERN_OFF, PATTERN_OFF, PATTERN_ON, PATTERN_OFF]).connect(combine)
else:
FrontpanelLed(which=0, boolean=False, patterns=[PATTERN_OFF, PATTERN_OFF, PATTERN_OFF, PATTERN_OFF]).connect(combine)
FrontpanelLed(which=1, boolean=False, patterns=[PATTERN_OFF, PATTERN_OFF, PATTERN_OFF, PATTERN_OFF]).connect(combine)
def __init__(self, session):
self.initcomplete = False
service = session and session.nav.getCurrentService()
feinfo = service and service.frontendInfo()
self.frontendData = feinfo and feinfo.getAll(True)
del feinfo
del service
self.preDefTransponders = None
self.TerrestrialTransponders = None
self.CableTransponders = None
self.typeOfTuningEntry = None
self.systemEntry = None
self.systemEntryATSC = None
self.satfinderTunerEntry = None
self.satEntry = None
self.typeOfInputEntry = None
self.frequencyEntry = None
self.polarizationEntry = None
self.symbolrateEntry = None
self.inversionEntry = None
self.rolloffEntry = None
self.pilotEntry = None
self.modulationEntry = None
self.fecEntry = None
self.transponder = None
self.DVB_TypeEntry = None
self.systemEntryTerr = None
ScanSetup.__init__(self, session)
self.setTitle(_("Signal Finder"))
self["introduction"].setText(_("Press OK to scan"))
self["Frontend"] = FrontendStatus(
frontend_source=lambda: self.frontend, update_interval=100)
self["actions"] = ActionMap(
["SetupActions", "ColorActions"], {
"save": self.keyGoScan,
"ok": self.keyGoScan,
"cancel": self.keyCancel,
}, -3)
self.initcomplete = True
self.session.postScanService = self.session.nav.getCurrentlyPlayingServiceOrGroup(
)
self.onClose.append(self.__onClose)
self.onShow.append(self.prepareFrontend)
def __init__(self, session, args=0):
self.printconfig()
self.session = session
Screen.__init__(self, session)
Screen.setTitle(self, _("AutoBouquetsMaker"))
self.frontend = None
self.rawchannel = None
self.postScanService = None
self.providers = Manager().getProviders()
self["actions"] = ActionMap(["OkCancelActions", "ColorActions"], {
"cancel": self.keyCancel,
"red": self.keyCancel,
}, -2)
# self["background"] = Pixmap()
self["action"] = Label(_("Starting scanner"))
self["status"] = Label("")
self["progress"] = ProgressBar()
self["progress_text"] = Progress()
self["tuner_text"] = Label("")
self["Frontend"] = FrontendStatus(
frontend_source=lambda: self.frontend, update_interval=100)
# dependent providers
self.dependents = {}
for provider_key in self.providers:
if len(self.providers[provider_key]
["dependent"]) > 0 and self.providers[provider_key][
"dependent"] in self.providers:
if self.providers[provider_key][
"dependent"] not in self.dependents:
self.dependents[self.providers[provider_key]
["dependent"]] = []
self.dependents[self.providers[provider_key]
["dependent"]].append(provider_key)
# get ABM config string including dependents
self.abm_settings_str = self.getABMsettings()
self.actionsList = []
self.onFirstExecBegin.append(self.firstExec)
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 __init__(self, session):
self.initcomplete = False
service = session and session.nav.getCurrentService()
feinfo = service and service.frontendInfo()
self.frontendData = feinfo and feinfo.getAll(True)
del feinfo
del service
self.typeOfTuningEntry = None
self.systemEntry = None
self.systemEntryATSC = None
self.satfinderTunerEntry = None
self.satEntry = None
self.typeOfInputEntry = None
self.DVB_TypeEntry = None
self.systemEntryTerr = None
self.preDefTransponderEntry = None
self.preDefTransponderCableEntry = None
self.preDefTransponderTerrEntry = None
self.preDefTransponderAtscEntry = None
self.frontend = None
self.is_id_boolEntry = None
self.t2mi_plp_id_boolEntry = None
self.timer = eTimer()
self.timer.callback.append(self.updateFrontendStatus)
ScanSetup.__init__(self, session)
self.entryChanged = self.newConfig
self.setTitle(_("Signal finder"))
self["Frontend"] = FrontendStatus(frontend_source=lambda: self.frontend, update_interval=100)
self["actions"] = ActionMap(["CancelSaveActions"],
{
"save": self.keyGoScan,
"cancel": self.keyCancel,
"close": self.doCloseRecursive,
}, -3)
self.initcomplete = True
self.session.postScanService = self.session.nav.getCurrentlyPlayingServiceOrGroup()
self.session.nav.stopService()
self.onClose.append(self.__onClose)
self.onShow.append(self.prepareFrontend)
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 __init__(self, session):
self.initcomplete = False
service = session and session.nav.getCurrentService()
feinfo = service and service.frontendInfo()
self.frontendData = feinfo and feinfo.getAll(True)
del feinfo
del service
self.typeOfTuningEntry = None
self.systemEntry = None
self.systemEntryATSC = None
self.satfinderTunerEntry = None
self.satEntry = None
self.typeOfInputEntry = None
self.DVB_TypeEntry = None
self.systemEntryTerr = None
self.preDefTransponderEntry = None
self.preDefTransponderCableEntry = None
self.preDefTransponderTerrEntry = None
self.preDefTransponderAtscEntry = None
self.frontend = None
self.is_id_boolEntry = None
ScanSetup.__init__(self, session)
self.setTitle(_("Signal finder"))
self["Frontend"] = FrontendStatus(frontend_source = lambda : self.frontend, update_interval = 100)
self["key_red"] = Label(_("Exit"))
self["actions"] = ActionMap(["SetupActions", "ColorActions"],
{
"save": self.keyGoScan,
"ok": self.keyGoScan,
"cancel": self.keyCancel,
}, -3)
self.initcomplete = True
self.session.postScanService = self.session.nav.getCurrentlyPlayingServiceOrGroup()
self.onClose.append(self.__onClose)
self.onShow.append(self.prepareFrontend)
def __init__(self, session):
self.initcomplete = False
service = session and session.nav.getCurrentService()
feinfo = service and service.frontendInfo()
self.frontendData = feinfo and feinfo.getAll(True)
del feinfo
del service
self.preDefTransponders = None
self.CableTransponders = None
self.ATSCTransponders = None
self.typeOfTuningEntry = None
self.systemEntry = None
self.systemEntryATSC = None
self.satfinderTunerEntry = None
self.satEntry = None
self.frequencyEntry = None
self.polarizationEntry = None
self.symbolrateEntry = None
self.inversionEntry = None
self.rolloffEntry = None
self.pilotEntry = None
self.fecEntry = None
self.transponder = None
ScanSetup.__init__(self, session)
self.setTitle(_('Signal Finder'))
self['introduction'].setText(_('Press OK to scan'))
self['Frontend'] = FrontendStatus(
frontend_source=lambda: self.frontend, update_interval=100)
self['actions'] = ActionMap(['SetupActions', 'ColorActions'], {
'save': self.keyGoScan,
'ok': self.keyGoScan,
'cancel': self.keyCancel
}, -3)
self.initcomplete = True
self.session.postScanService = self.session.nav.getCurrentlyPlayingServiceOrGroup(
)
self.onClose.append(self.__onClose)
self.onShow.append(self.prepareFrontend)
return
def __init__(self, session, args = 0):
print "[RadioTimesEmulator][__init__] Starting..."
print "[RadioTimesEmulator][__init__] args", args
self.session = session
Screen.__init__(self, session)
Screen.setTitle(self, _("Radio Times Emulator Download"))
if not inStandby:
self["action"] = Label(_("Starting downloader"))
self["status"] = Label("")
self["progress"] = ProgressBar()
self["progress_text"] = Progress()
self["tuner_text"] = Label("")
self["actions"] = ActionMap(["SetupActions"],
{
"cancel": self.keyCancel,
}, -2)
self.selectedNIM = -1
if args:
pass
self.frontend = None
if not inStandby:
self["Frontend"] = FrontendStatus(frontend_source = lambda : self.frontend, update_interval = 100)
self.rawchannel = None
# self.session.postScanService = self.session.nav.getCurrentlyPlayingServiceOrGroup()
self.postScanService = None
self.index = 0
self.LOCK_TIMEOUT_ROTOR = 1200 # 100ms for tick - 120 sec
self.LOCK_TIMEOUT_FIXED = 50 # 100ms for tick - 5 sec
self.LOCK_TIMEOUT = self.LOCK_TIMEOUT_FIXED
self.databaseLocation = "%sradiotimes" % config.plugins.RadioTimesEmulator.database_location.value
self.providers = Providers().read()
self.onClose.append(self.__onClose)
self.onFirstExecBegin.append(self.firstExec)
def __init__(self, session, args=0):
print "[TerrestrialScan][__init__] Starting..."
print "[TerrestrialScan][__init__] args", args
self.session = session
Screen.__init__(self, session)
Screen.setTitle(self, _("TerrestrialScan"))
self["background"] = Pixmap()
self["action"] = Label(_("Starting scanner"))
self["status"] = Label("")
self["progress"] = ProgressBar()
self["progress_text"] = Progress()
self["actions"] = ActionMap(["SetupActions"], {
"cancel": self.keyCancel,
}, -2)
self.selectedNIM = -1
self.uhf_vhf = "uhf"
self.networkid = 0
self.restrict_to_networkid = False
if args:
if "feid" in args:
self.selectedNIM = args["feid"]
if "uhf_vhf" in args:
self.uhf_vhf = args["uhf_vhf"]
if "networkid" in args:
self.networkid = args["networkid"]
if "restrict_to_networkid" in args:
self.restrict_to_networkid = args["restrict_to_networkid"]
self.isT2tuner = False
self.frontend = None
self["Frontend"] = FrontendStatus(
frontend_source=lambda: self.frontend, update_interval=100)
self.rawchannel = None
self.session.postScanService = self.session.nav.getCurrentlyPlayingServiceOrGroup(
)
self.index = 0
self.frequency = 0
self.system = eDVBFrontendParametersTerrestrial.System_DVB_T
self.lockTimeout = 50 # 100ms for tick - 5 sec
self.tsidOnidTimeout = 100 # 100ms for tick - 10 sec
self.snrTimeout = 100 # 100ms for tick - 10 sec
self.bandwidth = 8 # MHz
self.scanTransponders = []
if self.uhf_vhf == "uhf_vhf":
bandwidth = 7
for a in range(5, 13):
for b in (eDVBFrontendParametersTerrestrial.System_DVB_T,
eDVBFrontendParametersTerrestrial.System_DVB_T2
): # system
self.scanTransponders.append({
"frequency":
channel2freq(a, bandwidth),
"system":
b,
"bandwidth":
bandwidth
})
if self.uhf_vhf in ("uhf", "uhf_vhf"):
bandwidth = 8
for a in range(21, 70):
for b in (eDVBFrontendParametersTerrestrial.System_DVB_T,
eDVBFrontendParametersTerrestrial.System_DVB_T2
): # system
self.scanTransponders.append({
"frequency":
channel2freq(a, bandwidth),
"system":
b,
"bandwidth":
bandwidth
})
if self.uhf_vhf == "australia":
bandwidth = 7
base_frequency = 177500000
for a in range(0, 8) + range(50, 74):
freq = (base_frequency + (a * bandwidth * 1000000 +
(2000000 if a > 8 else 0)))
self.scanTransponders.append({
"frequency":
freq,
"system":
eDVBFrontendParametersTerrestrial.System_DVB_T,
"bandwidth":
bandwidth
})
self.transponders_found = []
self.transponders_unique = {}
self.onClose.append(self.__onClose)
self.onFirstExecBegin.append(self.firstExec)
def __init__(self, session):
Screen.__init__(self, session)
self["CurrentService"] = CurrentService(session.nav)
self["Event_Now"] = EventInfo(session.nav, EventInfo.NOW)
self["Event_Next"] = EventInfo(session.nav, EventInfo.NEXT)
self["FrontendStatus"] = FrontendStatus(
service_source=session.nav.getCurrentService)
self["FrontendInfo"] = FrontendInfo(navcore=session.nav)
self["VideoPicture"] = Source()
self["TunerInfo"] = TunerInfo()
self["RecordState"] = RecordState(session)
self["Standby"] = Boolean(fixed=False)
self["HddSleepingState"] = HddState(session)
from Components.SystemInfo import SystemInfo
combine = Combine(func=lambda s: {
(False, False): 0,
(False, True): 1,
(True, False): 2,
(True, True): 3
}[(s[0].boolean, s[1].boolean)])
combine.connect(self["Standby"])
combine.connect(self["RecordState"])
combine.connect(self["HddSleepingState"])
# | two leds | single led |
# recordstate standby red green
# false false off on off
# true false blnk on blnk
# false true on off off
# true true blnk off blnk
PATTERN_ON = (20, 0xffffffff, 0xffffffff)
PATTERN_OFF = (20, 0, 0)
PATTERN_BLINK = (20, 0x55555555, 0xa7fccf7a)
NormalLed0 = PATTERN_OFF
NormalLed1 = PATTERN_OFF
if config.usage.frontled_color.value == "1":
NormalLed0 = PATTERN_ON
if config.usage.frontled_color.value == "2":
NormalLed1 = PATTERN_ON
if config.usage.frontled_color.value == "3":
NormalLed0 = PATTERN_BLINK
if config.usage.frontled_color.value == "4":
NormalLed1 = PATTERN_BLINK
RecLed0 = PATTERN_OFF
RecLed1 = PATTERN_OFF
if config.usage.frontledrec_color.value == "1":
RecLed0 = PATTERN_ON
if config.usage.frontledrec_color.value == "2":
RecLed1 = PATTERN_ON
if config.usage.frontledrec_color.value == "3":
RecLed0 = PATTERN_BLINK
if config.usage.frontledrec_color.value == "4":
RecLed1 = PATTERN_BLINK
StandbyLed0 = PATTERN_OFF
StandbyLed1 = PATTERN_OFF
if config.usage.frontledstdby_color.value == "1":
StandbyLed0 = PATTERN_ON
if config.usage.frontledstdby_color.value == "2":
StandbyLed1 = PATTERN_ON
if config.usage.frontledstdby_color.value == "3":
StandbyLed0 = PATTERN_BLINK
if config.usage.frontledstdby_color.value == "4":
StandbyLed1 = PATTERN_BLINK
RecstdbyLed0 = PATTERN_OFF
RecstdbyLed1 = PATTERN_OFF
if config.usage.frontledrecstdby_color.value == "1":
RecstdbyLed0 = PATTERN_ON
if config.usage.frontledrecstdby_color.value == "2":
RecstdbyLed1 = PATTERN_ON
if config.usage.frontledrecstdby_color.value == "3":
RecstdbyLed0 = PATTERN_BLINK
if config.usage.frontledrecstdby_color.value == "4":
RecstdbyLed1 = PATTERN_BLINK
nr_leds = SystemInfo.get("NumFrontpanelLEDs", 0)
if nr_leds == 1:
FrontpanelLed(which=0,
boolean=False,
patterns=[
PATTERN_OFF, PATTERN_BLINK, PATTERN_OFF,
PATTERN_BLINK
]).connect(combine)
elif nr_leds == 2:
if getBoxType() == "dm520":
FrontpanelLed(which=0,
boolean=False,
patterns=[
PATTERN_ON, PATTERN_BLINK, PATTERN_OFF,
PATTERN_BLINK
]).connect(combine)
FrontpanelLed(which=1,
boolean=False,
patterns=[
PATTERN_OFF, PATTERN_OFF, PATTERN_OFF,
PATTERN_OFF
]).connect(combine)
elif getMachineBuild() == "dm4kgen":
FrontpanelLed(
which=0,
boolean=False,
patterns=[NormalLed0, RecLed0, StandbyLed0,
RecstdbyLed0]).connect(combine)
FrontpanelLed(
which=1,
boolean=False,
patterns=[NormalLed1, RecLed1, StandbyLed1,
RecstdbyLed1]).connect(combine)
else:
FrontpanelLed(which=0,
boolean=False,
patterns=[
PATTERN_OFF, PATTERN_BLINK, PATTERN_ON,
PATTERN_BLINK
]).connect(combine)
FrontpanelLed(which=1,
boolean=False,
patterns=[
PATTERN_ON, PATTERN_ON, PATTERN_OFF,
PATTERN_OFF
]).connect(combine)
def __init__(self, session, providers, pcallback = None, noosd = False):
from Components.Sources.StaticText import StaticText
from Components.Sources.Progress import Progress
if (getDesktop(0).size().width() < 800):
skin = "%s/skins/downloader_sd.xml" % os.path.dirname(sys.modules[__name__].__file__)
self.isHD = 0
else:
skin = "%s/skins/downloader_hd.xml" % os.path.dirname(sys.modules[__name__].__file__)
self.isHD = 1
f = open(skin, "r")
self.skin = f.read()
f.close()
Screen.__init__(self, session)
self.skinName = "downloader"
self.session = session
self["background"] = Pixmap()
self["action"] = Label(_("Starting downloader"))
self["status"] = Label("")
self["progress"] = ProgressBar()
self["progress"].hide()
self["progress_text"] = Progress()
self["summary_action"] = StaticText(_("Starting downloader"))
self["summary_status"] = StaticText()
self["summary_progress"] = Progress()
self["actions"] = NumberActionMap(["WizardActions", "InputActions"],
{
"back": self.quit
}, -1)
self.frontend = None
self["Frontend"] = FrontendStatus(frontend_source = lambda : self.frontend, update_interval = 100)
self.rawchannel = None
self.retValue = True
self.provider_index = 0
self.status = 0
self.open = False
self.saved = False
self.oldService = None
# make config
self.legacy = True
for slot in nimmanager.nim_slots:
if slot.canBeCompatible("DVB-S"):
try:
slot.config.dvbs
self.legacy = False
except:
self.legacy = True
break
self.config = CrossEPG_Config()
self.config.load()
self.providers = providers
self.pcallback = pcallback
self.wrapper = CrossEPG_Wrapper()
self.wrapper.addCallback(self.wrapperCallback)
self.hideprogress = eTimer()
self.hideprogress.callback.append(self["progress"].hide)
self.pcallbacktimer = eTimer()
self.pcallbacktimer.callback.append(self.doCallback)
self.wrappertimer = eTimer()
self.wrappertimer.callback.append(self.initWrapper)
if noosd:
self.wrappertimer.start(100, 1)
else:
self.onFirstExecBegin.append(self.firstExec)
def __init__(self, session, args=0):
print "[ABM-FrequencyFinder][__init__] Starting..."
print "[ABM-FrequencyFinder][__init__] args", args
self.session = session
Screen.__init__(self, session)
Screen.setTitle(self, _("FrequencyFinder"))
self.skinName = ["AutoBouquetsMaker"]
self.frontend = None
self.rawchannel = None
self["background"] = Pixmap()
self["action"] = Label(_("Starting scanner"))
self["status"] = Label("")
self["progress"] = ProgressBar()
self["progress_text"] = Progress()
self["Frontend"] = FrontendStatus(
frontend_source=lambda: self.frontend, update_interval=100)
self["actions"] = ActionMap(["SetupActions"], {
"cancel": self.keyCancel,
}, -2)
self.selectedNIM = -1 # -1 is automatic selection
self.uhf_vhf = "uhf"
self.networkid = 0 # this is an onid, not a regional network id
self.restrict_to_networkid = False
if args: # These can be added in ABM config at some time in the future
if "feid" in args:
self.selectedNIM = args["feid"]
if "uhf_vhf" in args:
self.uhf_vhf = args["uhf_vhf"]
if "networkid" in args:
self.networkid = args["networkid"]
if "restrict_to_networkid" in args:
self.restrict_to_networkid = args["restrict_to_networkid"]
self.isT2tuner = False # unlikely any modern internal terrestrial tuner can't play T2, but some USB tuners can't
self.session.postScanService = None
self.index = 0
self.frequency = 0
self.system = eDVBFrontendParametersTerrestrial.System_DVB_T
self.lockTimeout = 50 # 100ms for tick - 5 sec
self.snrTimeout = 100 # 100ms for tick - 10 sec
#self.bandwidth = 8 # MHz
self.scanTransponders = []
if self.uhf_vhf == "uhf_vhf":
bandwidth = 7
for a in range(5, 13): # channel
for b in (eDVBFrontendParametersTerrestrial.System_DVB_T,
eDVBFrontendParametersTerrestrial.System_DVB_T2
): # system
self.scanTransponders.append({
"frequency":
channel2freq(a, bandwidth),
"system":
b,
"bandwidth":
bandwidth
})
if self.uhf_vhf in ("uhf", "uhf_vhf"):
bandwidth = 8
for a in range(21, 70): # channel
for b in (eDVBFrontendParametersTerrestrial.System_DVB_T,
eDVBFrontendParametersTerrestrial.System_DVB_T2
): # system
self.scanTransponders.append({
"frequency":
channel2freq(a, bandwidth),
"system":
b,
"bandwidth":
bandwidth
})
self.transponders_found = []
self.transponders_unique = {}
# self.custom_dir = os.path.dirname(__file__) + "/../custom"
# self.customfile = self.custom_dir + "/CustomTranspondersOverride.xml"
# self.removeFileIfExists(self.customfile)
self.providers_dir = os.path.dirname(__file__) + "/../providers"
self.providersfile = self.providers_dir + "/terrestrial_finder.xml"
self.network_name = None
self.onClose.append(self.__onClose)
self.onFirstExecBegin.append(self.firstExec)
def __init__(self, session):
Screen.__init__(self, session)
self['CurrentService'] = CurrentService(session.nav)
self['CurrentTime'] = Clock()
self['Event_Now'] = EventInfo(session.nav, EventInfo.NOW)
self['Event_Next'] = EventInfo(session.nav, EventInfo.NEXT)
self['FrontendStatus'] = FrontendStatus(
service_source=session.nav.getCurrentService)
self['FrontendInfo'] = FrontendInfo(navcore=session.nav)
self['VideoPicture'] = Source()
self['TunerInfo'] = TunerInfo()
self['RecordState'] = RecordState(session)
self['Standby'] = Boolean(fixed=False)
from Components.SystemInfo import SystemInfo
combine = Combine(func=lambda s: {
(False, False): 0,
(False, True): 1,
(True, False): 2,
(True, True): 3
}[s[0].boolean, s[1].boolean])
combine.connect(self['Standby'])
combine.connect(self['RecordState'])
PATTERN_ON = (20, 4294967295, 4294967295)
PATTERN_OFF = (20, 0, 0)
PATTERN_BLINK = (20, 1431655765, 2818363258)
have_display = SystemInfo.get('FrontpanelDisplay', False)
have_touch_sensor = SystemInfo.get('HaveTouchSensor', False)
nr_leds = SystemInfo.get('NumFrontpanelLEDs', 0)
if nr_leds == 1:
FrontpanelLed(which=0,
boolean=False,
patterns=[
PATTERN_OFF if have_display else PATTERN_ON,
PATTERN_BLINK, PATTERN_OFF, PATTERN_BLINK
]).connect(combine)
elif nr_leds == 2:
if have_touch_sensor:
FrontpanelLed(which=0,
boolean=False,
patterns=[
PATTERN_ON, PATTERN_BLINK, PATTERN_OFF,
PATTERN_BLINK
]).connect(combine)
FrontpanelLed(which=1,
boolean=False,
patterns=[
PATTERN_OFF, PATTERN_OFF, PATTERN_OFF,
PATTERN_OFF
]).connect(combine)
else:
FrontpanelLed(which=0,
boolean=False,
patterns=[
PATTERN_OFF, PATTERN_BLINK, PATTERN_ON,
PATTERN_BLINK
]).connect(combine)
FrontpanelLed(which=1,
boolean=False,
patterns=[
PATTERN_ON, PATTERN_ON, PATTERN_OFF,
PATTERN_OFF
]).connect(combine)
def __init__(self, session, args=0):
print("[MakeBouquet][__init__] Starting...")
print("[MakeBouquet][__init__] args", args)
self.session = session
Screen.__init__(self, session)
Screen.setTitle(self, _("MakeBouquet"))
self.skinName = ["TerrestrialScan"]
self.path = "/etc/enigma2"
self.services_dict = {}
self.tmp_services_dict = {}
self.namespace_dict = {
} # to store namespace when sub network is enabled
self.logical_channel_number_dict = {}
self.ignore_visible_service_flag = False # make this a user override later if found necessary
self.VIDEO_ALLOWED_TYPES = [1, 4, 5, 17, 22, 24, 25, 27, 135]
self.AUDIO_ALLOWED_TYPES = [2, 10]
self.BOUQUET_PREFIX = "userbouquet.TerrestrialScan."
self.bouquetsIndexFilename = "bouquets.tv"
self.bouquetFilename = self.BOUQUET_PREFIX + "tv"
self.bouquetName = _('Terrestrial')
self.namespace_complete_terrestrial = not (
config.usage.subnetwork_terrestrial.value if hasattr(
config.usage, "subnetwork_terrestrial") else True
) # config.usage.subnetwork not available in all images
self.terrestrialXmlFilename = "terrestrial.xml"
self.frontend = None
self.rawchannel = None
self["background"] = Pixmap()
self["action"] = Label(_("Starting scanner"))
self["status"] = Label("")
self["progress"] = ProgressBar()
self["progress_text"] = Progress()
self["tuner_text"] = Label("")
self["Frontend"] = FrontendStatus(
frontend_source=lambda: self.frontend, update_interval=100)
self["actions"] = ActionMap(["SetupActions"], {
"cancel": self.keyCancel,
}, -2)
self.selectedNIM = -1
self.transponders_unique = {}
self.FTA_only = False
self.makebouquet = True
self.makexmlfile = False
self.lcndescriptor = 0x83
self.channel_list_id = 0
if args:
if "feid" in args:
self.selectedNIM = args["feid"]
if "transponders_unique" in args:
self.transponders_unique = args["transponders_unique"]
if "FTA_only" in args:
self.FTA_only = args["FTA_only"]
if "makebouquet" in args:
self.makebouquet = args["makebouquet"]
if "makexmlfile" in args:
self.makexmlfile = args["makexmlfile"]
if "lcndescriptor" in args:
self.lcndescriptor = args["lcndescriptor"]
if "channel_list_id" in args:
self.channel_list_id = args["channel_list_id"]
self.tsidOnidKeys = list(self.transponders_unique.keys())
self.index = 0
self.lockTimeout = 50 # 100ms for tick - 5 sec
self.onClose.append(self.__onClose)
self.onFirstExecBegin.append(self.firstExec)
def __init__(self, session, args=0):
print("[TerrestrialScan][__init__] Starting...")
print("[TerrestrialScan][__init__] args", args)
self.session = session
Screen.__init__(self, session)
Screen.setTitle(self, _("TerrestrialScan"))
self["background"] = Pixmap()
self["action"] = Label(_("Starting scanner"))
self["status"] = Label("")
self["progress"] = ProgressBar()
self["progress_text"] = Progress()
self["tuner_text"] = Label("")
self["actions"] = ActionMap(["SetupActions"], {
"cancel": self.keyCancel,
}, -2)
self.selectedNIM = -1
self.uhf_vhf = "uhf"
self.networkid = 0
self.restrict_to_networkid = False
self.stabliseTime = 2 # time in seconds for tuner to stablise on tune before taking a signal quality reading
self.region = None
if args:
if "feid" in args:
self.selectedNIM = args["feid"]
if "uhf_vhf" in args:
self.uhf_vhf = args["uhf_vhf"]
if "networkid" in args:
self.networkid = args["networkid"]
if "restrict_to_networkid" in args:
self.restrict_to_networkid = args["restrict_to_networkid"]
if "stabliseTime" in args:
self.stabliseTime = args["stabliseTime"]
if "region" in args:
self.region = args["region"]
self.isT2tuner = False
self.frontend = None
self["Frontend"] = FrontendStatus(
frontend_source=lambda: self.frontend, update_interval=100)
self.rawchannel = None
self.session.postScanService = self.session.nav.getCurrentlyPlayingServiceOrGroup(
)
self.index = 0
self.frequency = 0
self.system = eDVBFrontendParametersTerrestrial.System_DVB_T
self.lockTimeout = 50 # 100ms for tick - 5 sec
self.tsidOnidTimeout = 100 # 100ms for tick - 10 sec
self.snrTimeout = 100 # 100ms for tick - 10 sec
self.bandwidth = 8 # MHz
self.scanTransponders = []
if self.uhf_vhf == "uhf_vhf":
bandwidth = 7
for a in range(5, 13):
for b in (eDVBFrontendParametersTerrestrial.System_DVB_T,
eDVBFrontendParametersTerrestrial.System_DVB_T2
): # system
self.scanTransponders.append({
"frequency":
channel2freq(a, bandwidth),
"system":
b,
"bandwidth":
bandwidth
})
if self.uhf_vhf in ("uhf", "uhf_vhf"):
bandwidth = 8
for a in range(21, 70):
for b in (eDVBFrontendParametersTerrestrial.System_DVB_T,
eDVBFrontendParametersTerrestrial.System_DVB_T2
): # system
self.scanTransponders.append({
"frequency":
channel2freq(a, bandwidth),
"system":
b,
"bandwidth":
bandwidth
})
if self.uhf_vhf == "australia":
bandwidth = 7
base_frequency = 177500000
for a in range(0, 8) + range(50, 74):
freq = (base_frequency + (a * bandwidth * 1000000 +
(2000000 if a > 8 else 0)))
self.scanTransponders.append({
"frequency":
freq,
"system":
eDVBFrontendParametersTerrestrial.System_DVB_T,
"bandwidth":
bandwidth
})
if self.uhf_vhf == "xml":
# frequency 1, inversion 9, bandwidth 2, fechigh 4, feclow 5, modulation 3, transmission 7, guard 6, hierarchy 8, system 10, plp_id 1
for tp in nimmanager.getTranspondersTerrestrial(self.region):
# system contains "-1" when both DVB-T and DVB-T2 are to be scanned
if tp[10] < 1: # DVB-T
self.scanTransponders.append({
"frequency":
tp[1],
"system":
eDVBFrontendParametersTerrestrial.System_DVB_T,
"bandwidth":
tp[2] // 1000000
})
if tp[10] != 0: # DVB-T2
self.scanTransponders.append({
"frequency":
tp[1],
"system":
eDVBFrontendParametersTerrestrial.System_DVB_T2,
"bandwidth":
tp[2] // 1000000
})
self.transponders_found = []
self.transponders_unique = {}
self.onClose.append(self.__onClose)
self.onFirstExecBegin.append(self.firstExec)
