コード例 #1
0
	def BumpTemp(self, setpoint, degrees):

		debugprint(config.dbgscreenbuild, "Bump temp: ", setpoint, degrees)
		debugprint(config.dbgscreenbuild, "New: ", self.info[setpoint][0] + degrees)
		r = config.ISYrequestsession.get(
			config.ISYprefix + 'nodes/' + self.RealObj.address + '/set/' + setpoint + '/' + str(
				self.info[setpoint][0] + degrees))
コード例 #2
0
    def __init__(self, screensection, screenname):
        debugprint(config.dbgscreenbuild, "New WeatherScreenDesc ", screenname)

        screen.ScreenDesc.__init__(self, screensection, screenname,
                                   (('which', ('', )), ))
        utilities.LocalizeParams(self,
                                 screensection,
                                 WunderKey='',
                                 location='')
        self.scrlabel = screen.FlatenScreenLabel(self.label)
        # entries are (fontsize, centered, formatstring, values)
        self.conditions = [
            (2, True, "{d}", self.scrlabel),
            (1, True, "{d[0]}", ('Location', )),
            (1, False, u"Now: {d[0]} {d[1]}\u00B0F", ('Sky', 'Temp')),
            (0, False, u"  Feels like: {d[0]}\u00B0", ('Feels', )),
            (1, False, "Wind {d[0]}", ('WindStr', )),
            (1, False, "Sunrise: {d[0]:02d}:{d[1]:02d}", ('SunriseH',
                                                          'SunriseM')),
            (1, False, "Sunset:  {d[0]:02d}:{d[1]:02d}", ('SunsetH',
                                                          'SunsetM')),
            (0, False, "Moon rise: {d[0]} set: {d[1]}", ('Moonrise',
                                                         'Moonset')),
            (0, False, "     {d[0]}% illuminated", ('MoonPct', )),
            (0, False, "will be replaced", "")
        ]
        self.forecast = [
            (1, False, u"{d[0]}   {d[1]}\u00B0/{d[2]}\u00B0 {d[3]}",
             ('Day', 'High', 'Low', 'Sky')),
            (1, False, "Wind: {d[0]} at {d[1]}", ('WindDir', 'WindSpd'))
        ]
        self.Info = weatherinfo.WeatherInfo(self.WunderKey, self.location)
        utilities.register_example("WeatherScreenDesc", self)
コード例 #3
0
ファイル: isy.py プロジェクト: jimmypuckett/softconsole
 def SendCommand(self, state, fast):
     selcmd = (('DOF', 'DFOF'), ('DON', 'DFON'))
     config.debugprint(ISYdebug, "OnOff sent: ", selcmd[state][fast],
                       ' to ', self.name)
     url = 'http://' + config.ISYaddr + '/rest/nodes/' + self.address + '/cmd/' + selcmd[
         state][fast]
     r = config.ISYrequestsession.get(url)
     return r
コード例 #4
0
def event_feed(*arg):
    data = arg[0]
    if config.seq <> int(data["Event-seqnum"]):
        config.fromDaemon.put(
            ("Log", "Event mismatch - Expected: " + str(config.seq) +
             " Got: " + str(data["Event-seqnum"]), ConsoleWarning))
        config.seq = int(data["Event-seqnum"]) + 1
    else:
        config.seq += 1

    if config.streamid <> data["Event-sid"]:
        config.fromDaemon.put(
            ("Log", "Now using event stream: " + str(data["Event-sid"]),
             ConsoleWarning))
        config.streamid = data["Event-sid"]

    if time.time() < config.watchstarttime + 10:
        debugprint(config.dbgdaemon, time.time(), "Skipping item in stream: ",
                   data["Event-seqnum"], ":", data["control"], " : ",
                   data["node"], " : ", data["eventInfo"], " : ",
                   data["action"])
        return None

    while not config.toDaemon.empty():
        msg = config.toDaemon.get()
        if len(msg) == 0:
            config.watchlist = ["empty"]
        else:
            config.watchlist = msg
        debugprint(config.dbgdaemon, time.time(), "New watchlist: ",
                   config.watchlist)

    data = arg[0]
    # data["Event-seqnum"],":",prcode," : ",data["node"]," : ",data["eventInfo"]," : ",data["action"]," : ",data["Event-sid"])

    eventcode = data["control"]
    if eventcode in EVENT_CTRL:
        prcode = EVENT_CTRL[eventcode]
    # print "Orig EC", eventcode, prcode
    else:
        prcode = "**" + eventcode + "**"
    # print "Ugly EC", eventcode, prcode
    if (prcode == "Status"
            or config.watchlist[0] == "") and data["node"] in config.watchlist:
        debugprint(config.dbgdaemon, time.time(), "Status update in stream: ",
                   data["Event-seqnum"], ":", prcode, " : ", data["node"],
                   " : ", data["eventInfo"], " : ", data["action"])
        config.fromDaemon.put(("Node", data["node"], data["action"]))
        debugprint(config.dbgdaemon, "Qsize at daemon ",
                   config.fromDaemon.qsize())
    else:
        debugprint(config.dbgdaemon, time.time(), "Other  update in stream: ",
                   data["Event-seqnum"], ":", prcode, " : ", data["node"],
                   " : ", data["eventInfo"], " : ", data["action"])
コード例 #5
0
 def __init__(self, screensection, screenname):
     debugprint(config.dbgscreenbuild, "Build Clock Screen")
     screen.ScreenDesc.__init__(self, screensection, screenname)
     utilities.LocalizeParams(self,
                              screensection,
                              CharSize=[20],
                              Font='droidsansmono',
                              OutFormat=[])
     for i in range(len(self.CharSize), len(self.OutFormat)):
         self.CharSize.append(self.CharSize[-1])
     utilities.register_example("ClockScreen", self)
コード例 #6
0
def Watcher():
    config.watchstarttime = time.time()
    config.watchlist = ['init']
    debugprint(config.dbgdaemon, "Watcher: ", config.watchstarttime,
               os.getpid())
    server = ISYEvent()
    server.subscribe(addr=config.ISYaddr,
                     userl=config.ISYuser,
                     userp=config.ISYpassword)
    server.set_process_func(event_feed, "")

    server.events_loop()
コード例 #7
0
 def __init__(self, screensection, screenname):
     debugprint(config.dbgscreenbuild, "Build House Status Screen")
     screen.ScreenDesc.__init__(self, screensection, screenname,
                                ())  # no extra cmd keys
     utilities.LocalizeParams(self,
                              screensection,
                              NormalOn=[],
                              NormalOff=[])
     checklist = [
         nm for nm in config.ISY.NodesByName
         if ((nm in self.NormalOn) or (nm in self.NormalOff))
     ]  # addr -> name
     utilities.register_example("HouseStatusScreenDesc", self)
コード例 #8
0
    def __init__(self, screensection, screenname):
        debugprint(config.dbgscreenbuild, "New KeyScreenDesc ", screenname)
        screen.BaseKeyScreenDesc.__init__(self, screensection, screenname)
        self.subscriptionlist = {}

        # Build the Key objects
        for keyname in screensection:
            if isinstance(screensection[keyname], Section):
                NewKey = keydesc.KeyDesc(screensection[keyname], keyname)
                self.keysbyord.append(NewKey)

        self.LayoutKeys()
        utilities.register_example("KeyScreenDesc", self)
コード例 #9
0
	def __init__(self, screensection, screenname):
		debugprint(config.dbgscreenbuild, "New ThermostatScreenDesc ", screenname)
		screen.BaseKeyScreenDesc.__init__(self, screensection, screenname)
		utilities.LocalizeParams(self, screensection, 'KeyColor', 'KeyOffOutlineColor', 'KeyOnOutlineColor')
		self.info = {}
		self.fsize = (30, 50, 80, 160)

		if screenname in config.ISY.NodesByName:
			self.RealObj = config.ISY.NodesByName[screenname]
		else:
			self.RealObj = None
			config.Logs.Log("No Thermostat: " + screenname, severity=logsupport.ConsoleWarning)

		self.TitleRen = config.fonts.Font(self.fsize[1]).render(screen.FlatenScreenLabel(self.label), 0,
																wc(self.CharColor))
		self.TitlePos = ((config.screenwidth - self.TitleRen.get_width())/2, config.topborder)
		self.TempPos = config.topborder + self.TitleRen.get_height()
		self.StatePos = self.TempPos + config.fonts.Font(self.fsize[3]).get_linesize() - scaleH(20)
		self.SPPos = self.StatePos + scaleH(25)
		self.AdjButSurf = pygame.Surface((config.screenwidth, scaleH(40)))
		self.AdjButTops = self.SPPos + config.fonts.Font(self.fsize[2]).get_linesize() - scaleH(5)
		centerspacing = config.screenwidth/5
		self.AdjButSurf.fill(wc(self.BackgroundColor))
		arrowsize = scaleH(40)  # pixel

		for i in range(4):
			gfxdraw.filled_trigon(self.AdjButSurf, *trifromtop(centerspacing, arrowsize/2, i + 1, arrowsize,
															   wc(("red", "blue", "red", "blue")[i]), i%2 <> 0))
			self.keysbyord.append(toucharea.TouchPoint((centerspacing*(i + 1), self.AdjButTops + arrowsize/2),
													   (arrowsize*1.2, arrowsize*1.2)))
		self.ModeButPos = self.AdjButTops + scaleH(85)  # pixel

		bsize = (scaleW(100), scaleH(50))  # pixel
		self.keysbyord.append(toucharea.ManualKeyDesc("Mode", ["Mode"],
													  self.KeyColor, self.CharColor, self.CharColor,
													  center=(config.screenwidth/4, self.ModeButPos), size=bsize,
													  KOn=config.KeyOffOutlineColor))  # todo clean up
		self.keysbyord.append(toucharea.ManualKeyDesc("Fan", ["Fan"],
													  self.KeyColor, self.CharColor, self.CharColor,
													  center=(3*config.screenwidth/4, self.ModeButPos), size=bsize,
													  KOn=config.KeyOffOutlineColor))
		self.keysbyord[4].FinishKey((0,0),(0,0))
		self.keysbyord[5].FinishKey((0,0),(0,0))
		self.ModesPos = self.ModeButPos + bsize[1]/2 + scaleH(5)
		utilities.register_example("ThermostatScreenDesc", self)
コード例 #10
0
	def HandleScreen(self, newscr=True):

		# stop any watching for device stream
		config.toDaemon.put(["", self.RealObj.address])

		self.ShowScreen()

		while 1:
			choice = config.DS.NewWaitPress(self)
			if choice[0] == WAITEXIT:
				return choice[1]
			elif (choice[0] == WAITNORMALBUTTON) or (choice[0] == WAITNORMALBUTTONFAST):
				if choice[1] < 4:
					self.BumpTemp(('CLISPH', 'CLISPH', 'CLISPC', 'CLISPC')[choice[1]], (2, -2, 2, -2)[choice[1]])
				else:
					self.BumpMode(('CLIMD', 'CLIFS')[choice[1] - 4], (range(8), (7, 8))[choice[1] - 4])
			elif choice[0] == WAITISYCHANGE:
				debugprint(config.dbgscreenbuild, "Thermo change", choice)
				self.ShowScreen()
コード例 #11
0
 def __init__(self, keys):
     debugprint(config.dbgscreenbuild, "Build Maintenance Screen")
     screen.BaseKeyScreenDesc.__init__(self,
                                       fixedoverrides,
                                       'Maint',
                                       withnav=False)
     utilities.LocalizeParams(self, None, TitleFontSize=40, SubFontSize=25)
     self.keysbyord = []
     for k, kt in keys.iteritems():
         self.keysbyord.append(
             toucharea.ManualKeyDesc(k, [kt[0]],
                                     'gold',
                                     'black',
                                     'black',
                                     KOn='black',
                                     KOff='black',
                                     proc=kt[1]))
     topoff = self.TitleFontSize + self.SubFontSize
     self.LayoutKeys(topoff,
                     config.screenheight - 2 * config.topborder - topoff)
     utilities.register_example("MaintScreenDesc", self)
コード例 #12
0
	def BumpMode(self, mode, vals):
		debugprint(config.dbgscreenbuild, "Bump mode: ", mode, vals)
		cv = vals.index(self.info[mode][0])
		debugprint(config.dbgscreenbuild, cv, vals[cv])
		cv = (cv + 1)%len(vals)
		debugprint(config.dbgscreenbuild, "new cv: ", cv)
		r = config.ISYrequestsession.get(
			config.ISYprefix + 'nodes/' + self.RealObj.address + '/set/' + mode + '/' + str(vals[cv]))
コード例 #13
0
    def __init__(self, screensection, screenname):
        debugprint(config.dbgscreenbuild, "New TimeTempDesc ", screenname)

        screen.ScreenDesc.__init__(self, screensection, screenname)
        utilities.LocalizeParams(self,
                                 screensection,
                                 WunderKey='',
                                 location='',
                                 CharSize=[20],
                                 Font='droidsansmono',
                                 TimeFormat=[],
                                 ConditionFields=[],
                                 ConditionFormat=[],
                                 ForecastFields=[],
                                 ForecastFormat=[],
                                 ForecastDays=1)
        self.scrlabel = screen.FlatenScreenLabel(self.label)
        self.WInfo = weatherinfo.WeatherInfo(self.WunderKey, self.location)
        for i in range(
                len(self.CharSize),
                len(self.TimeFormat) + len(self.ConditionFormat) +
                len(self.ForecastFormat)):
            self.CharSize.append(self.CharSize[-1])
コード例 #14
0
	def ShowScreen(self):
		self.PaintBase()
		r = config.ISYrequestsession.get('http://' + config.ISYaddr + '/rest/nodes/' + self.RealObj.address,
										 verify=False)
		tstatdict = xmltodict.parse(r.text)
		props = tstatdict["nodeInfo"]["properties"]["property"]

		self.info = {}
		for item in props:
			debugprint(config.dbgscreenbuild, item["@id"], ":", item["@value"], ":", item["@formatted"])
			self.info[item["@id"]] = (int(item['@value']), item['@formatted'])
		config.screen.blit(self.TitleRen, self.TitlePos)
		r = config.fonts.Font(self.fsize[3], bold=True).render(u"{:4.1f}".format(self.info["ST"][0]/2), 0,
															   wc(self.CharColor))
		config.screen.blit(r, ((config.screenwidth - r.get_width())/2, self.TempPos))
		if isinstance(self.info["CLIHCS"][0], int):
			r = config.fonts.Font(self.fsize[0]).render(("Idle", "Heating", "Cooling")[self.info["CLIHCS"][0]], 0,
													wc(self.CharColor))
		else:
			r = config.fonts.Font(self.fsize[0]).render("n/a", 0, wc(self.CharColor))
		config.screen.blit(r, ((config.screenwidth - r.get_width())/2, self.StatePos))
		r = config.fonts.Font(self.fsize[2]).render(
			"{:2d}    {:2d}".format(self.info["CLISPH"][0]/2, self.info["CLISPC"][0]/2), 0,
			wc(self.CharColor))
		config.screen.blit(r, ((config.screenwidth - r.get_width())/2, self.SPPos))
		config.screen.blit(self.AdjButSurf, (0, self.AdjButTops))
		self.keysbyord[4].PaintKey()
		self.keysbyord[5].PaintKey()
		r1 = config.fonts.Font(self.fsize[1]).render(
			('Off', 'Heat', 'Cool', 'Auto', 'Fan', 'Prog Auto', 'Prog Heat', 'Prog Cool')[self.info["CLIMD"][0]], 0,
			wc(self.CharColor))
		r2 = config.fonts.Font(self.fsize[1]).render(('On', 'Auto')[self.info["CLIFS"][0] - 7], 0, wc(self.CharColor))
		config.screen.blit(r1, (self.keysbyord[4].Center[0] - r1.get_width()/2, self.ModesPos))
		config.screen.blit(r2, (self.keysbyord[5].Center[0] - r2.get_width()/2, self.ModesPos))

		pygame.display.update()
コード例 #15
0
    def NewWaitPress(self,
                     ActiveScreen,
                     callbackint=0,
                     callbackproc=None,
                     callbackcount=0):

        self.AS = ActiveScreen
        cycle = 0
        if callbackint <> 0:  # todo needs a better structural fix for posted actions that persist across Waitpress calls
            pygame.time.set_timer(self.INTERVALHIT.type,
                                  int(callbackint * 1000))
            cycle = callbackcount if callbackcount <> 0 else 100000000  # essentially infinite
        if self.isDim and self.AS == config.DimHomeScreenCover:
            pygame.time.set_timer(
                self.GOHOMEHIT.type,
                0)  # in final quiet state so cancel gohome until a touch
        else:
            pygame.time.set_timer(
                self.MAXTIMEHIT.type, self.AS.DimTO *
                1000)  # if not in final quiet state set dim timer

        while True:
            rtn = (0, 0)

            event = pygame.fastevent.poll()

            if event.type == pygame.NOEVENT:
                time.sleep(.01)
                pass
            elif event.type == pygame.MOUSEBUTTONDOWN:
                pos = (pygame.mouse.get_pos()[0], pygame.mouse.get_pos()[1])
                # if self.presscount < 10:  # this is debug code for a weird/unreproducible RPi behavior where touch is off
                #	print pos
                #	self.presscount += 1
                tapcount = 1
                pygame.time.delay(config.MultiTapTime)
                while True:
                    eventx = pygame.fastevent.poll()
                    if eventx.type == pygame.NOEVENT:
                        break
                    elif eventx.type == pygame.MOUSEBUTTONDOWN:
                        tapcount += 1
                        pygame.time.delay(config.MultiTapTime)
                    else:
                        continue
                if tapcount > 2:
                    self.GoDim(False)
                    rtn = (WAITEXIT, tapcount)
                    break
                # on any touch reset return to home screen
                pygame.time.set_timer(self.GOHOMEHIT.type,
                                      int(config.HomeScreenTO) * 1000)
                # on any touch restart dim timer and reset to bright if dim
                pygame.time.set_timer(self.MAXTIMEHIT.type,
                                      self.AS.DimTO * 1000)
                dimscr = self.GoDim(False)
                if dimscr is not None:
                    rtn = (WAITEXIT, config.HomeScreen)
                    break

                for i in range(len(self.AS.keysbyord)):
                    K = self.AS.keysbyord[i]
                    if toucharea.InBut(pos, K):
                        if tapcount == 1:
                            rtn = (WAITNORMALBUTTON, i)
                        else:
                            rtn = (WAITNORMALBUTTONFAST, i)
                if self.AS.PrevScreen is not None:
                    if toucharea.InBut(pos, self.AS.PrevScreenKey):
                        rtn = (WAITEXIT, self.AS.PrevScreen)
                    elif toucharea.InBut(pos, self.AS.NextScreenKey):
                        rtn = (WAITEXIT, self.AS.NextScreen)
                for K in self.AS.ExtraCmdKeys:
                    if toucharea.InBut(pos, K):
                        rtn = (WAITEXTRACONTROLBUTTON, K.name)
                if rtn[0] <> 0:
                    break
                continue

            elif event.type == self.MAXTIMEHIT.type:
                dimscr = self.GoDim(True)
                if dimscr is not None:
                    rtn = (WAITEXIT, dimscr)
                    break
                continue
            elif event.type == self.INTERVALHIT.type:
                if (callbackproc is not None) and (cycle > 0):
                    callbackproc(cycle)
                    cycle -= 1
                continue
            elif event.type == self.GOHOMEHIT.type:
                rtn = (WAITEXIT, config.HomeScreen)
                break
            else:
                pass  # ignore and flush other events

            if (not config.fromDaemon.empty()) and (
                    cycle
                    == 0):  # todo don't process daemon reports while cycling
                debugprint(config.dbgMain, "Q size at main loop ",
                           config.fromDaemon.qsize())
                item = config.fromDaemon.get()
                debugprint(config.dbgMain, time.time(), "ISY reports change: ",
                           "Key: ", str(item))
                if item[0] == "Log":
                    config.Logs.Log(item[1], severity=item[2])
                    continue
                elif item[0] == "Node":
                    rtn = (WAITISYCHANGE, (item[1], item[2]))
                    break
                else:
                    config.Logs.Log("Bad msg from watcher: " + str(item),
                                    Severity=ConsoleWarning)

        pygame.time.set_timer(self.INTERVALHIT.type, 0)
        pygame.time.set_timer(self.MAXTIMEHIT.type, 0)

        return rtn
コード例 #16
0
ファイル: isy.py プロジェクト: jimmypuckett/softconsole
 def runThen(self):
     config.debugprint(ISYdebug, "runThen sent to ", self.name)
     url = config.ISYprefix + 'programs/' + self.address + '/runThen'
     r = config.ISYrequestsession.get(url)
     return r
コード例 #17
0
ファイル: keydesc.py プロジェクト: jimmypuckett/softconsole
    def __init__(self, keysection, keyname):
        debugprint(config.dbgscreenbuild, "             New Key Desc ",
                   keyname)
        toucharea.ManualKeyDesc.__init__(self, keysection, keyname)
        utilities.LocalizeParams(self,
                                 keysection,
                                 SceneProxy='',
                                 KeyRunThenName='',
                                 type='ONOFF')
        self.MonitorObj = None  # ISY Object monitored to reflect state in the key (generally a device within a Scene)

        # for ONOFF keys (and others later) map the real and monitored nodes in the ISY
        # map the key to a scene or device - prefer to map to a scene so check that first
        # Obj is the representation of the ISY Object itself, addr is the address of the ISY device/scene
        if self.type in ('ONOFF'):
            if keyname in config.ISY.ScenesByName:
                self.RealObj = config.ISY.ScenesByName[keyname]
                if self.SceneProxy <> '':
                    # explicit proxy assigned
                    if self.SceneProxy in config.ISY.NodesByAddr:
                        # address given
                        self.MonitorObj = config.ISY.NodesByAddr[
                            self.SceneProxy]
                    elif self.SceneProxy in config.ISY.NodesByName:
                        self.MonitorObj = config.ISY.NodesByName[
                            self.SceneProxy]
                    else:
                        config.Logs.Log('Bad explicit scene proxy:' +
                                        self.name,
                                        severity=ConsoleWarning)
                else:
                    for i in self.RealObj.members:
                        device = i[1]
                        if device.enabled and device.hasstatus:
                            self.MonitorObj = device
                            break
                        else:
                            config.Logs.Log(
                                'Skipping disabled/nonstatus device: ' +
                                device.name,
                                severity=ConsoleWarning)
                    if self.MonitorObj is None:
                        config.Logs.Log("No proxy for scene: " + keyname,
                                        severity=ConsoleError)
                    #debugprint(config.dbgscreenbuild, "Scene ", keyname, " default proxying with ",
                    #		   self.MonitorObj.name)
            elif keyname in config.ISY.NodesByName:
                self.RealObj = config.ISY.NodesByName[keyname]
                self.MonitorObj = self.RealObj
            else:
                debugprint(config.dbgscreenbuild, "Screen", keyname, "unbound")
                config.Logs.Log('Key Binding missing: ' + self.name,
                                severity=ConsoleWarning)
        elif self.type in ("ONBLINKRUNTHEN"):
            self.State = False
            try:
                self.RealObj = config.ISY.ProgramsByName[self.KeyRunThenName]
            except:
                self.RealObj = None
                debugprint(config.dbgscreenbuild, "Unbound program key: ",
                           self.label)
                config.Logs.Log("Missing Prog binding: " + self.name,
                                severity=ConsoleWarning)
        else:
            debugprint(config.dbgscreenbuild, "Unknown key type: ", self.label)
            config.Logs.Log("Bad keytype: " + self.name,
                            severity=ConsoleWarning)

        utilities.register_example("KeyDesc", self)

        debugprint(config.dbgscreenbuild, repr(self))
コード例 #18
0
    def __init__(self):

        thisconfig = config.ParsedConfigFile

        debugprint(config.dbgscreenbuild, "Process Configuration File")

        mainlist = {}
        secondlist = {}
        extralist = {}

        for screenitem in thisconfig:
            NewScreen = None
            if isinstance(thisconfig[screenitem], Section):
                thisScreen = thisconfig[screenitem]
                # its a screen
                tempscreentype = thisScreen.get("type", "unspec")
                debugprint(config.dbgscreenbuild, "Screen of type ",
                           tempscreentype)

                if tempscreentype in config.screentypes:
                    NewScreen = config.screentypes[tempscreentype](thisScreen,
                                                                   screenitem)
                    config.Logs.Log(tempscreentype + " screen " + screenitem)
                else:
                    config.Logs.Log("Screentype error" + screenitem +
                                    " type " + tempscreentype,
                                    severity=ConsoleWarning)
                    pass
            if NewScreen is not None:
                # set the standard navigation keys and navigation linkages
                if NewScreen.name in config.MainChain:
                    mainlist[NewScreen.name] = NewScreen
                elif NewScreen.name in config.SecondaryChain:
                    secondlist[NewScreen.name] = NewScreen
                else:
                    extralist[NewScreen.name] = NewScreen
                    config.ExtraChain.append(NewScreen.name)

        if len(secondlist) == 0:
            secondlist = extralist
            config.SecondaryChain = config.ExtraChain
            config.ExtraChain = []
        config.Logs.Log("Main Screen List:")
        for scr in config.MainChain:
            if not scr in mainlist:
                config.Logs.Log("-- Undefined Screen:",
                                scr,
                                severity=ConsoleWarning)
                config.MainChain.remove(scr)
        for scr in config.MainChain:
            if scr in mainlist:
                S = mainlist[scr]
                S.PrevScreen = mainlist[config.MainChain[
                    config.MainChain.index(scr) - 1]]
                S.NextScreen = mainlist[config.MainChain[
                    (config.MainChain.index(scr) + 1) % len(config.MainChain)]]
                config.Logs.Log("---" + scr)

        config.Logs.Log("Secondary Screen List:")
        for scr in config.SecondaryChain:
            if not scr in secondlist:
                config.Logs.Log("-- Undefined Screen:",
                                scr,
                                severity=ConsoleWarning)
                config.SecondaryChain.remove(scr)
        for scr in config.SecondaryChain:
            if scr in secondlist:
                S = secondlist[scr]
                S.PrevScreen = secondlist[config.SecondaryChain[
                    config.SecondaryChain.index(scr) - 1]]
                S.NextScreen = secondlist[config.SecondaryChain[
                    (config.SecondaryChain.index(scr) + 1) %
                    len(config.SecondaryChain)]]
                config.Logs.Log("---" + scr)

        config.Logs.Log("Not on a screen list (unavailable)",
                        severity=ConsoleWarning)
        for scr in config.ExtraChain:
            config.Logs.Log("---" + scr, severity=ConsoleWarning)

        for S in mainlist.itervalues():
            S.FinishScreen()
        for S in secondlist.itervalues():
            S.FinishScreen()

        if config.HomeScreenName in config.MainChain:
            config.HomeScreen = mainlist[config.HomeScreenName]
        else:
            config.Logs.Log("Error in Home Screen Name",
                            severity=ConsoleWarning)
            config.HomeScreen = mainlist[config.MainChain[0]]

        config.HomeScreen2 = secondlist[config.SecondaryChain[0]]

        config.Logs.Log("Home Screen: " + config.HomeScreen.name)
        if config.DimHomeScreenCoverName in config.MainChain:  # todo why must it be on MainChain?
            config.DimHomeScreenCover = mainlist[config.DimHomeScreenCoverName]
            config.Logs.Log("Dim Home Screen: " +
                            config.DimHomeScreenCover.name)
        else:
            config.DimHomeScreenCover = config.HomeScreen
            config.Logs.Log("No Dim Home Screen Cover Set")
        config.Logs.Log("First Secondary Screen: " + config.HomeScreen2.name)
コード例 #19
0
config.Logs.Log("Enumerated ISY Structure")
"""
Build the ISY object structure and connect the configured screens to it
"""
configobjects.MyScreens()
config.Logs.Log("Linked config to ISY")
"""
Set up the watcher daemon and its communications
"""
config.toDaemon = Queue(300)
config.fromDaemon = Queue(300)
p = Process(target=watchdaemon.Watcher, name="Watcher")
p.daemon = True
p.start()
config.DaemonProcess = p
debugprint(config.dbgMain, "Spawned watcher as: ", p.pid)
config.Logs.Log("Watcher pid: " + str(p.pid))

config.Logs.livelog = False  # turn off logging to the screen and give user a moment to scan
time.sleep(2)
# config.backlight.ChangeDutyCycle(config.BrightLevel)
"""
Set up the Maintenance Screen
"""
config.Logs.Log("Built Maintenance Screen")
maintscreen.SetUpMaintScreens()
"""
Dump documentation
"""
utilities.DumpDocumentation()
コード例 #20
0
    def HandleScreen(self, newscr=True):
        def BlinkKey(scr, key, cycle):
            # thistime = finalstate if cycle % 2 <> 0 else not finalstate
            key.State = not key.State
            key.PaintKey()

        if newscr:
            # key screen change actually occurred
            self.PaintBase()
            self.subscriptionlist = {}
            debugprint(config.dbgMain, "Switching to screen: ", self.name)
            for K in self.keysbyord:
                if K.MonitorObj is not None:
                    # skip program buttons
                    self.subscriptionlist[K.MonitorObj.address] = K
            states = isy.get_real_time_status(self.subscriptionlist.keys())
            for K in self.keysbyord:
                if K.MonitorObj is not None:
                    K.State = not (states[K.MonitorObj.address] == 0
                                   )  # K is off (false) only if state is 0

            debugprint(config.dbgMain, "Active Subscription List will be:")
            addressestoscanfor = ["Status"]
            for i in self.subscriptionlist:
                debugprint(config.dbgMain, "  Subscribe: ", i,
                           self.subscriptionlist[i].name, " : ",
                           self.subscriptionlist[i].RealObj.name, ' via ',
                           self.subscriptionlist[i].MonitorObj.name)
                addressestoscanfor.append(i)
            config.toDaemon.put(addressestoscanfor)
            self.PaintKeys()
        else:
            debugprint(config.dbgMain, "Skipping screen recreation: ",
                       self.name)

        blinkproc = None
        blinktime = 0
        blinks = 0

        while 1:
            choice = config.DS.NewWaitPress(self,
                                            callbackint=blinktime,
                                            callbackproc=blinkproc,
                                            callbackcount=blinks)
            blinkproc = None
            blinktime = 0
            blinks = 0
            if (choice[0] == WAITNORMALBUTTON) or (choice[0]
                                                   == WAITNORMALBUTTONFAST):
                # handle various keytype cases
                K = self.keysbyord[choice[1]]
                if K.type == "ONOFF":
                    K.State = not K.State
                    if K.RealObj is not None:
                        K.RealObj.SendCommand(K.State,
                                              choice[0] <> WAITNORMALBUTTON)
                    # config.Logs.Log("Sent command to " + K.RealObj.name)
                    else:
                        config.Logs.Log("Screen: " + self.name +
                                        " press unbound key: " + K.name,
                                        severity=logsupport.ConsoleWarning)
                    K.PaintKey()
                elif K.type == "ONBLINKRUNTHEN":
                    # force double tap for programs for safety - too easy to accidentally single tap with touchscreen
                    if choice[0] == WAITNORMALBUTTONFAST:
                        K.RealObj.runThen()
                        blinkproc = functools.partial(BlinkKey, config.screen,
                                                      K)
                        blinktime = .5
                        blinks = 8  # even number leaves final state of key same as initial state
                        K.PaintKey()
                    # leave K.State as is - key will return to off at end
                elif K.type == "ONOFFRUN":
                    pass
            elif choice[0] == WAITEXIT:
                return choice[1]
            elif choice[0] == WAITISYCHANGE:
                K = self.subscriptionlist[choice[1][0]]
                ActState = int(choice[1][1]) <> 0

                if ActState <> K.State:
                    K.State = ActState
                    K.PaintKey()