Beispiel #1
0
	def TryCommand(self, state, fast):
		selcmd = (('DOF', 'DFOF'), ('DON', 'DFON'))
		config.debugPrint('ISY', "OnOff sent: ", selcmd[state][fast], ' to ', self.name)
		url = 'http://' + config.ISYaddr + '/rest/nodes/' + self.address + '/cmd/' + selcmd[state][fast]
		try:
			r = config.ISYrequestsession.get(url, verify=False)
		except requests.exceptions.ConnectTimeout:
			config.Logs.Log("ISY Comm Timeout (Send Cmd): " + self.address + 'Cmd: ' + selcmd[state][fast],
							severity=ConsoleError)
			config.Logs.Log(sys.exc_info()[1], severity=ConsoleError)
			return (1, 0)
		except requests.exceptions.ConnectionError:
			config.Logs.Log("ISY Comm ConnErr (Send Cmd): " + self.address + 'Cmd: ' + selcmd[state][fast],
							severity=ConsoleError)
			config.Logs.Log(sys.exc_info()[1], severity=ConsoleError)
			return (2, 0)
		except:
			config.Logs.Log("ISY Comm UnknownErr (Send Cmd): " + self.address + 'Cmd: ' + selcmd[state][fast],
							severity=ConsoleError)
			config.Logs.Log(sys.exc_info()[1], severity=ConsoleError)
			return (3, 0)
		if r.status_code <> 200:
			config.Logs.Log(
				'ISY Bad status (Send Cmd)' + str(r.status_code) + ' on ' + self.address + 'Cmd: ' + selcmd[state][
					fast], severity=ConsoleError)
			config.Logs.Log(r.text)
			return (4, r.status_code)
		else:
			return (0, 200)
Beispiel #2
0
def try_status(addr):
	# returns (code, respstatus, devicestatus)
	try:
		t = 'http://' + config.ISYaddr + '/rest/status/' + addr
		config.debugPrint('ISY', t)
		r = config.ISYrequestsession.get(t, verify=False)
	except requests.exceptions.ConnectTimeout:
		config.Logs.Log("ISY Comm Timeout (RT status): " + addr, severity=ConsoleError)
		config.Logs.Log(sys.exc_info()[1], severity=ConsoleError)
		return (1, 0, False)
	except requests.exceptions.ConnectionError:
		config.Logs.Log("ISY Comm ConnErr (RT status): " + addr, severity=ConsoleError)
		config.Logs.Log(sys.exc_info()[1], severity=ConsoleError)
		return (2, 0, False)
	except:
		config.Logs.Log("ISY Comm UnknownErr (RT status): " + addr, severity=ConsoleError)
		config.Logs.Log(sys.exc_info()[1], severity=ConsoleError)
		return (3, 0, False)
	if r.status_code <> 200:
		config.Logs.Log('ISY Bad status (RT status)' + str(r.status_code) + ' on ' + addr, severity=ConsoleError)
		config.Logs.Log(r.text)
		return (4, r.status_code, False)
	else:
		props = xmltodict.parse(r.text)['properties']['property']
		if isinstance(props, dict):
			props = [props]
		devstate = 0
		for item in props:
			if item['@id'] == "ST":
				devstate = item['@value']
				break
		return (0, 200, devstate)
	def BumpTemp(self, setpoint, degrees):

		debugPrint('Main', "Bump temp: ", setpoint, degrees)
		debugPrint('Main', "New: ", self.info[setpoint][0] + degrees)
		r = config.ISYrequestsession.get(
			config.ISYprefix + 'nodes/' + self.RealObj.address + '/set/' + setpoint + '/' + str(
				self.info[setpoint][0] + degrees))
Beispiel #4
0
	def __init__(self, screensection, screenname):
		debugPrint('BuildScreen', "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)
Beispiel #5
0
	def __init__(self, screensection, screenname):
		debugPrint('BuildScreen', "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)
Beispiel #6
0
def Watcher():
	config.watchstarttime = time.time()
	config.watchlist = ['init']
	debugPrint('Daemon', "Watcher: ", config.watchstarttime, os.getpid())
	config.Daemon_pid = os.getpid()
	server = ISYEvent()  # can add parameter debug = 3 to have library dump some info out output
	server.subscribe(addr=config.ISYaddr, userl=config.ISYuser, userp=config.ISYpassword)
	server.set_process_func(event_feed, "")

	server.events_loop()
	def __init__(self, screensection, screenname):
		debugPrint('BuildScreen', "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, SkipDays=0)
		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])
Beispiel #8
0
 def __init__(self, keys):
     debugPrint("BuildScreen", "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", "white", KOn="black", KOff="white", proc=kt[1])
         )
     topoff = self.TitleFontSize + self.SubFontSize
     self.LayoutKeys(topoff, config.screenheight - 2 * config.topborder - topoff)
     utilities.register_example("MaintScreenDesc", self)
Beispiel #9
0
	def __init__(self, screensection, screenname):
		debugPrint('BuildScreen', "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)
Beispiel #10
0
	def SendCommand(self, state, fast):
		try:
			for i in range(3):
				error, status_code = self.TryCommand(state, fast)
				if error == 0:  # good result
					raise GotIt()
				else:
					config.debugPrint('ISY', 'Send command failed', str(error), str(status_code))
					time.sleep(.5)
					config.Logs.Log("Attempting ISY retry (Send Cmd) " + str(i + 1), severity=ConsoleError)
			config.Logs.Log("ISY Communications Failure (Send Cmd)", severity=ConsoleError)
			maintscreen.errorexit('reboot')
		except GotIt:
			pass
Beispiel #11
0
	def __init__(self):

		config.debugPrint("Main", "Screensize: ", config.screenwidth, config.screenheight)
		config.Logs.Log("Screensize: " + str(config.screenwidth) + " x " + str(config.screenheight))
		config.Logs.Log(
			"Scaling ratio: " + "{0:.2f}".format(config.dispratioW) + ':' + "{0:.2f}".format(config.dispratioH))

		# define user events
		self.MAXTIMEHIT = pygame.event.Event(pygame.USEREVENT)
		self.INTERVALHIT = pygame.event.Event(pygame.USEREVENT + 1)
		self.GOHOMEHIT = pygame.event.Event(pygame.USEREVENT + 2)
		self.DIMCYCLE = pygame.event.Event(pygame.USEREVENT + 3)
		self.dimscreenindex = 0
		self.isDim = False
		self.presscount = 0
		self.AS = None
		self.BrightenToHome = False
	def __init__(self, screensection, screenname):
		debugPrint('BuildScreen', "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)
	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('Main', "Thermo change", choice)
				self.ShowScreen()
Beispiel #14
0
def get_real_time_status(addrlist):
	# multiple calls here is substantially faster than one call for all status then selecting devices
	# this proc assumes a device that returns a simple ST value for status
	statusdict = {}
	for addr in addrlist:
		try:
			for i in range(3):
				error, status_code, devstate = try_status(addr)
				if error == 0:  # good result
					statusdict[addr] = int(devstate if devstate.isdigit() else 0)
					raise GotIt()
				else:
					config.debugPrint('ISY', 'Get status failed: ', str(error), str(status_code), str(devstate))
					time.sleep(.5)
					config.Logs.Log("Attempting ISY retry " + str(i + 1), severity=ConsoleError)
			config.Logs.Log("ISY Communications Failure", severity=ConsoleError)
			maintscreen.errorexit('reboot')
		except GotIt:
			pass
	config.debugPrint('ISY', statusdict)
	return statusdict
Beispiel #15
0
	def __init__(self, screensection, screenname):
		debugPrint('BuildScreen', "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)
	def BumpMode(self, mode, vals):
		debugPrint('Main', "Bump mode: ", mode, vals)
		cv = vals.index(self.info[mode][0])
		debugPrint('Main', cv, vals[cv])
		cv = (cv + 1)%len(vals)
		debugPrint('Main', "new cv: ", cv)
		r = config.ISYrequestsession.get(
			config.ISYprefix + 'nodes/' + self.RealObj.address + '/set/' + mode + '/' + str(vals[cv]))
	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('Main', 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()
Beispiel #18
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('Daemon', 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"]
		elif msg[0] == 'flagchange':
			config.Flags[msg[1]] = msg[2]
		else:
			config.watchlist = msg
		debugPrint('Daemon', 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('Daemon', time.time(), "Status update in stream: ", data["Event-seqnum"], ":", prcode, " : ",
				   data["node"], " : ", data["eventInfo"], " : ", data["action"])
		debugPrint('Daemon', time.time(), "Raw stream item: ", data)
		if data["action"] is dict:
			data["action"] = data["action"]["action"]
			debugPrint('Daemon', "V5 stream - pull up action value: ", data["action"])
		config.fromDaemon.put(("Node", data["node"], data["action"]))
		debugPrint('Daemon', "Qsize at daemon ", config.fromDaemon.qsize())
	else:
		config.debugPrint('Daemon', time.time(), "Other  update in stream: ", data["Event-seqnum"], ":", prcode, " : ",
						  data["node"], " : ", data["eventInfo"], " : ", data["action"])
		debugPrint('Daemon', time.time(), "Raw stream item: ", data)
Beispiel #19
0
	def runThen(self):
		config.debugPrint('ISY', "runThen sent to ", self.name)
		url = config.ISYprefix + 'programs/' + self.address + '/runThen'
		r = config.ISYrequestsession.get(url)
		return r
Beispiel #20
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.BrightenToHome:
			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 K.touched(pos):
						if tapcount == 1:
							rtn = (WAITNORMALBUTTON, i)
						else:
							rtn = (WAITNORMALBUTTONFAST, i)
				if self.AS.PrevScreen is not None:
					if self.AS.PrevScreenKey.touched(pos):
						rtn = (WAITEXIT, self.AS.PrevScreen)
					elif self.AS.NextScreenKey.touched(pos):
						rtn = (WAITEXIT, self.AS.NextScreen)
				for K in self.AS.ExtraCmdKeys:
					if K.touched(pos):
						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.DIMCYCLE.type:
				self.dimscreenindex = (self.dimscreenindex + 1)%len(config.DimIdleList)
				pygame.time.set_timer(self.DIMCYCLE.type, config.DimIdleTimes[self.dimscreenindex])
				rtn = (WAITEXIT, config.DimIdleList[self.dimscreenindex])
				break
			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('Main', "Q size at main loop ", config.fromDaemon.qsize())
				item = config.fromDaemon.get()
				debugPrint('Main', 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)

				# check for periodic alert items todo



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

		return rtn
Beispiel #21
0
	def __init__(self, keysection, keyname):
		debugPrint('BuildScreen', "             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]
						debugPrint('BuildScreen', "Scene ", keyname, " explicit address proxying with ",
								   self.MonitorObj.name, '(', self.SceneProxy, ')')
					elif self.SceneProxy in config.ISY.NodesByName:
						self.MonitorObj = config.ISY.NodesByName[self.SceneProxy]
						debugPrint('BuildScreen', "Scene ", keyname, " explicit name proxying with ",
								   self.MonitorObj.name, '(', self.MonitorObj.address, ')')
					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
							# todo   try to status the device here to see if it will respond
							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('BuildScreen', "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('BuildScreen', "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('BuildScreen', "Unbound program key: ", self.name)
				config.Logs.Log("Missing Prog binding: " + self.name, severity=ConsoleWarning)
		else:
			debugPrint('BuildScreen', "Unknown key type: ", self.name)
			config.Logs.Log("Bad keytype: " + self.name, severity=ConsoleWarning)

		utilities.register_example("KeyDesc", self)

		debugPrint('BuildScreen', repr(self))
Beispiel #22
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('Main', "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('Main', "Active Subscription List will be:")
			addressestoscanfor = ["Status"]
			for i in self.subscriptionlist:
				debugPrint('Main', "  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('Main', "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()
Beispiel #23
0
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
config.Daemon_pid = p.pid
debugPrint('Main', "Spawned watcher as: ", config.Daemon_pid)
config.Logs.Log("Watcher pid: " + str(config.Daemon_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
"""
Beispiel #24
0
	def __init__(self):

		thisconfig = config.ParsedConfigFile

		debugPrint('BuildScreen', "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('BuildScreen', "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)
		for sn, st in zip(config.DimIdleListNames, config.DimIdleListTimes):
			for l, d in zip((config.MainChain, config.SecondaryChain, config.ExtraChain),
							(mainlist, secondlist, extralist)):
				if sn in l:
					config.Logs.Log('Dim Screen: ' + sn + '/' + st)
					config.DimIdleList.append(d[sn])
					config.DimIdleTimes.append(int(st)*1000)

		# handle deprecated DimHomeScreenCoverName
		if config.DimHomeScreenCoverName <> "" and len(config.DimIdleList) == 0:
			if config.DimHomeScreenCoverName in config.MainChain:
				config.DimIdleList.append(mainlist[config.DimHomeScreenCoverName])
				config.DimIdleTimes.append(1000)
				config.Logs.Log("DimHS(deprecated): " + config.DimHomeScreenCoverName)

		if len(config.DimIdleList) == 0:
			config.DimIdleList[0] = config.HomeScreen
			config.DimIdleTimes[0] = 1000
			config.Logs.Log("No Dim Home Screen Cover Set")

		config.Logs.Log("First Secondary Screen: " + config.HomeScreen2.name)