i-have-a-dreambox.com | Dreambox - Support

Registrierung Kalender Mitgliederliste Teammitglieder Galerie Zum Portal Zur Startseite

Boardregeln Häufig gestellte Fragen Statistik Statistik Suche Pinwand Dreambox Blog Ihad/Gemini Fan-Shop
i-have-a-dreambox.com | Dreambox - Support » ...::: Skins :::... » Skin Workshop (Enigma2) » Homematic Plugin skinnen » Hallo Gast [Anmelden|Registrieren]
Letzter Beitrag | Erster ungelesener Beitrag Druckvorschau | Thema zu Favoriten hinzufügen
Neues Thema erstellen Antwort erstellen
Zum Ende der Seite springen Homematic Plugin skinnen
Autor
Beitrag « Vorheriges Thema | Nächstes Thema »
teejay
Stammuser


Dabei seit: 19.12.2008
Beiträge: 324
Welche Box: DM900; DM8000
Externe Speichermedien: CF-Card; HDD
Welches Image: OE 2.5; OE 2.0
Welcher Bildschirm: Panasonic TX P50

Homematic Plugin skinnen Auf diesen Beitrag antworten Zitatantwort auf diesen Beitrag erstellen Diesen Beitrag editieren/löschen Diesen Beitrag einem Moderator melden       Zum Anfang der Seite springen

Hallo Profis..

Ich würde gerne das Homematic Plugin bißchen Skinnen. (siehe Bild unten)

Ziel wären 2 BÜNDIGE Reihen bestehend aus 1.Gerät (bsp. Flur licht 1) und 2. Zustand (bsp AUS)

Großes Ziel wäre: Ich kann das Gewerk/Dirctonary (bsp. Beleuchtung) auf und zu klappen damit alles auf eine Seite passt..

Habe hier schon einige Workshops gelesen, komme aber mangels Kenntnis nicht weiter..

code:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:
206:
207:
208:
209:
210:
211:
212:
213:
214:
215:
216:
217:
218:
219:
220:
221:
222:
223:
224:
225:
226:
227:
228:
229:
230:
231:
232:
233:
234:
235:
236:
237:
238:
239:
240:
241:
242:
243:
244:
245:
246:
247:
248:
249:
250:
251:
252:
253:
254:
255:
256:
257:
258:
259:
260:
261:
262:
263:
264:
265:
266:
267:
268:
269:
270:
271:
272:
273:
274:
275:
276:
277:
278:
279:
280:
281:
282:
283:
284:
285:
286:
287:
288:
289:
290:
291:
292:
293:
294:
295:
296:
297:
298:
299:
300:
301:
302:
303:
304:
305:
306:
307:
308:
309:
310:
311:
312:
313:
314:
315:
316:
317:
318:
319:
320:
321:
322:
323:
324:
325:
326:
327:
328:
329:
330:
331:
332:
333:
334:
335:
336:
337:
338:
339:
340:
341:
342:
343:
344:
345:
346:
347:
348:
349:
350:
351:
352:
353:
354:
355:
356:
357:
358:
359:
360:
361:
362:
363:
364:
365:
366:
367:
368:
369:
370:
371:
372:
373:
374:
375:
376:
377:
378:
379:
380:
381:
382:
383:
384:
385:
386:
387:
388:
389:
390:
391:
392:
393:
394:
395:
396:
397:
398:
399:
400:
401:
402:
403:
404:
405:
406:
407:
408:
409:
410:
411:
412:
413:
414:
415:
416:
417:
418:
419:
420:
421:
422:
423:
424:
425:
426:
427:
428:
429:
430:
431:
432:
433:
434:
435:
436:
437:
438:
439:
440:
441:
442:
443:
444:
445:
446:
447:
448:
449:
450:
451:
452:
453:
454:
455:
456:
457:
458:
459:
460:
461:
462:
463:
464:
465:
466:
467:
468:
469:
470:
471:
472:
473:
474:
475:
476:
477:
478:
479:
480:
481:
482:
483:
484:
485:
486:
487:
488:
489:
490:
491:
492:
493:
494:
495:
496:
497:
498:
499:
500:
501:
502:
503:
504:
505:
506:
507:
508:
509:
510:
511:
512:
513:
514:
515:
516:
517:
518:
519:
520:
521:
522:
523:
524:
525:
526:
527:
528:
# Bedienung HM auf DM - 2015
# V0.6
# by ecki and natharn and lired
from Screens.Screen import Screen
from Components.MenuList import MenuList
from Components.ActionMap import ActionMap
from Screens.MessageBox import MessageBox
from Plugins.Plugin import PluginDescriptor
from Tools.LoadPixmap import LoadPixmap
import xmlrpclib
import re
import time
import httplib
import xml.etree.ElementTree as ET

#CCU-Daten eintragen
ccuip = "192.168.178.XXX"  #IP der CCU
portwd = "2000"		#Port Wired
portrf = "2001"		#Port Funk

#Wired oder Funk vorhanden
wdAvailable = False
rfAvailable = True

## Klasse fuer Kommunikation mit Homematic Wired ##########################################################################
class HM(object):
	__wd = xmlrpclib.ServerProxy("http://"+ccuip+":"+portwd)					   # IP der CCU Port:Wired
	__type = None
	__type2 = None

	# device - variable dictionary
	__dict_device =	{
	        "DIMMER" : "LEVEL",                                                                     
	        "BLIND" : "LEVEL",                                                                      
	        "SWITCH" : "STATE",
	        "CLIMATECONTROL_RT_TRANSCEIVER" : "ACTUAL_TEMPERATURE",
	        "THERMALCONTROL_TRANSMIT" : "SET_TEMPERATURE",
	        "WEATHER_TRANSMIT" : "HUMIDITY",
	        "ROTARY_HANDLE_SENSOR" : "STATE",
	        "SHUTTER_CONTACT" : "STATE",
	        "KEYMATIC" : "STATE"
	}     	

	def __init__(self, akz):
		self.__akz = akz
		self.__devdescription =  HM.__rf.getDeviceDescription (akz)   # Geraetetyp bestimmen
		self.__devtype = self.__devdescription['TYPE']
		self.__type = self.__dict_device[self.__devtype]		

#Werte von Homematik einlesen
	def get_Status (self ) :
		print "get_Status:", self.__akz, self.__type							  # Debug-Ausgabe an Konsole
		if self.__type:														   # wenn Typ definiert
			return HM.__wd.getValue ( self.__akz, self.__type )				   # Status holen
		else:
			return None														   # sonst gibt es nix
# Wert in Homematik-Aktor setzen	
	def set_Status (self, wert) :
		print "set_Status:", wert												 # Debug-Ausgabe an Konsole
		check = False
		if self.__type == "LEVEL":												# Fehler abfangen 
			print "Dimmer oder Rollo"											 # Debug-Ausgabe an Konsole
			wert = float (wert)												   # alles ok
			check = True
		elif self.__type == "STATE" and type (wert) == bool:					  # Fehler abfangen
			print "E/A Licht"													 # Debug-Ausgabe an Konsole
			check = True														  # alles ok
		else:
			print "TEST Fehler"												   # Debug-Ausgabe an Konsole
			return																# Fehler kein passender Wert vorhanden
		if check:
			print self.__akz, self.__type, wert								   # Debug-Ausgabe an Konsole
			HM.__wd.setValue ( self.__akz, self.__type, wert )					# Aktor neuen Wert zuweisen


	Status = property(get_Status, set_Status)

## Klasse fuer Kommunikation mit Homematic Funk ##########################################################################	
class HF(object):
	__rf = xmlrpclib.ServerProxy("http://"+ccuip+":"+portrf)					# IP der CCU Port:Funk
	__type = None
	__type2 = None

	# device - variable dictionary
	__dict_device =	{
	        "DIMMER" : "LEVEL",                                                                     
	        "BLIND" : "LEVEL",                                                                      
	        "SWITCH" : "STATE",
	        "CLIMATECONTROL_RT_TRANSCEIVER" : "ACTUAL_TEMPERATURE",
	        "THERMALCONTROL_TRANSMIT" : "SET_TEMPERATURE",
	        "WEATHER_TRANSMIT" : "HUMIDITY",
	        "ROTARY_HANDLE_SENSOR" : "STATE",
	        "SHUTTER_CONTACT" : "STATE",
	        "KEYMATIC" : "STATE"
	}     

# Abfrage vorbereiten - Geraetetyp und abgefragten Datenpunkt festlegen
	def __init__(self, akz):
		self.__akz = akz
		self.__devdescription =  HF.__rf.getDeviceDescription (akz)   # Geraetetyp bestimmen
		self.__devtype = self.__devdescription['TYPE']
		self.__type = self.__dict_device[self.__devtype]
		if self.__devtype == "KEYMATIC":
			self.__type2 = "OPEN"

# Werte von Homematic einlesen
	def get_Status (self) :
		print "**** get_Status:", self.__akz, self.__type					# Debug-Ausgabe an Konsole
		if self.__type:										# wenn Typ definiert
			return HF.__rf.getValue(self.__akz, self.__type)				        # Status holen
		else:
			return None				

# Wert in Homematik-Aktor setzen	
	def set_Status (self, wert) :
		print "**** set_Status:", wert								# Debug-Ausgabe an Konsole
		check = False
		if self.__type == "LEVEL":								# Fehler abfangen 
			print "**** Dimmer oder Rollo"								# Debug-Ausgabe an Konsole
			wert = float (wert)									# alles ok
			check = True
		elif self.__type == "SET_TEMPERATURE":							# Fehler abfangen 
			print "**** Solltemperatur"								# Debug-Ausgabe an Konsole
			wert = float (wert)									# alles ok
			check = True			
		elif self.__type == "STATE" and type (wert) == bool:					# Fehler abfangen
			print "**** E/A Licht"									# Debug-Ausgabe an Konsole
			check = True									# alles ok
		else:
			print "**** TEST Fehler"									# Debug-Ausgabe an Konsole
			return										# Fehler kein passender Wert vorhanden
		if check:
			print self.__akz, self.__type, wert							# Debug-Ausgabe an Konsole
			HF.__rf.setValue ( self.__akz, self.__type, wert )					# Aktor neuen Wert zuweisen

	# Wert in Open in Keymatic setzen   
	def set_StatusKM (self, wert2) :			
		print "**** set_Status:", wert2								# Debug-Ausgabe an Konsole
		check2 = False
		if self.__type2 == "OPEN":						 		# Fehler abfangen 
			print "**** Keymatic open"								# Debug-Ausgabe an Konsole
			check2 = True									# alles ok
		else:
			print "**** TEST Fehler"									# Debug-Ausgabe an Konsole
			return										# Fehler kein passender Wert vorhanden
		if check2:
			print self.__akz, self.__type2, wert2						# Debug-Ausgabe an Konsole
			HM.__rf.setValue ( self.__akz, self.__type2, wert2 )				# Aktor neuen Wert zuweisen

	Status = property(get_Status, set_Status)	
	KMStatus = property(get_Status, set_StatusKM)

## Klasse fuer Kommunikation mit Homematik Variablen lesen###########################################################
class HV(object):

# Abfrage vorbereiten - Ise_ID  festlegen
	def __init__(self, akz):
		self.__akz = akz
		self.__var = self.__akz

#Variable von Homematik einlesen
	def get_Var (self ) :
		print "get_Var:", self.__var,											# Debug-Ausgabe an Konsole
		if self.__var:														   # wenn Typ definiert
			__httpServ = httplib.HTTPConnection(ccuip, 80) 
			__httpServ.connect()
			__httpServ.request("GET", "/config/xmlapi/state.cgi?datapoint_id="+self.__var)
			__response = __httpServ.getresponse()
			__tree = ET.fromstring(__response.read())	
		for value in __tree:
			return value.get("value")	
		else:
			return None														   # sonst gibt es nix

# Wert in Homematik-Aktor setzen	
	def set_Var (self, wert) :
		wert = str(wert)
		print "set_Var:", self.__akz, wert,									   # Debug-Ausgabe an Konsole
		if wert:															  # Fehler abfangen
			__httpServ = httplib.HTTPConnection(ccuip, 80) 
			__httpServ.connect()
			__httpServ.request("GET", "/config/xmlapi/statechange.cgi?ise_id="+self.__akz+"&new_value="+wert)
		else:
			print "set_Status Fehler"											 # Debug-Ausgabe an Konsole
			return																# Fehler kein passender Wert vorhanden

	Varwert = property(get_Var, set_Var)



#Komponenten eintragen 
#Name : Kanal
dict_licht =	{
    "Wohnzimmer Stehlampe   " : HF ("KEQ0201xxx"),
    "Wohnzimmer Licht            " : HF ("KEQ00391xxx"),
    "Terrasse Licht 1                " : HF ("KEQ0200xxx"),
    "Terrasse Licht 2                " : HF ("KEQ0200xxxx"),
    "Flur Licht 1                       " : HF ("LEQ13384xxxx"),
    "Flur Licht 2                       " : HF ("LEQ1318xxxxx"),
    "Esszimmer Licht               " : HF ("JEQ0199xxxx"),    
    "Schlafzimmer Licht           " : HF ("JEQ0206xxxx")
}

dict_rollo =	{
     "Esszimmer        " : HF ("KEQ00950xxxx"),
     "Schlafzimmer 2 " : HF ("KEQ00941xxxx"),
     "Schlafzimmer 1 " : HF ("KEQ0095xxxx"),
     "Markise             " : HF ("LEQ14377xxxx"),
     "Wohnzimmer 1 " : HF ("KEQ0095xxxx"),
     "Wohnzimmer 2 " : HF ("KEQ0095xxxx"),
     "Wohnzimmer 3 " : HF ("KEQ0095xxxx"),
     "Wohnzimmer 4 " : HF ("KEQ0095xxxx"),
}					

dict_temperatur =	{
         "Wohnzimmer West  " : HF ("KEQ0734xxxx"),
         "Wohnzimmer Ost    " : HF ("KEQ0734xxxx"),
         "Esszimmer              " : HF ("KEQ0734xxxx"),
         "Schlafzimmer          " : HF ("KEQ0652xxxxx")
}

dict_wandthermo =	{
        #"Wohnzimmer   " : HF("LEQ0626065:1")
}							

dict_luftfeuchte =	{
        #"Luftfeucht    ": HF("LEQ0626065:1")
}														

dict_drehgriff =	{
        #"Fenstergriff UG Fitness" : HF("LEQ0564122:1"),
        #"Fenstergriff UG Technik" : HF("LEQ0564076:1")
}														

dict_tuerkontakt =	{
        #"UG Fitness" : HF("LEQ0504450:1")
}	

dict_keymatic =	{
        #"Wohnungstuer":  HF ("KEQ00xxxxxx")
} 

#Name : Ise_id	 
dict_var = {
       # "Alarmanlage scharf" : HV("1747"),
}

#Ueberschriften
headingLight =       "Beleuchtung"
headingShutter =     "Rolladen"
headingThermostat =  "Soll-Temperatur"
headingTemperature = "Temperaturen"
headingLock =        "Verschluss"
headingVariables =   "Variablen"

###########################################################################

class MyMenu(Screen):														   # Fenstergroesse und Position festlegen
	skin = """
	<screen flags="wfNoBorder" position="0,0" size="450,720" title="Homematic">
        <widget name="myMenu" position="30,5" size="350,720" scrollbarMode="showNever" transparent="1" zPosition="2"/>
	</screen>"""

	def __buildList(self, list):

################		Menuebaum Beleuchtung	   #############################
		if len(dict_licht)>0:
			list.append(headingLight)			# Trenner im Menue
			for adresse in sorted(dict_licht.keys ()):						 # Schaltaktoren und Dimmer (Licht) abfragen
				status = dict_licht[adresse].Status				#
				if not status:													  # wenn status false
					str_status = "aus"											  # dann ist der Schaltaktor AUS
				elif type (status) == float:										# wenn nicht und Datentyp float (Dimmer)
					str_status = "%3i"% (status*100) + " % "						# Wert uebernehmen,Umrechnung in % und Kommastelle abschneiden
				else:								#
					str_status = "an"											   # sonst ist der Schaltaktor AN
				str_Menu_Eintrag = adresse + "  -  "+ str_status					# aktueller Status fuer Menueeintrag 
				list.append((_(str_Menu_Eintrag), adresse))						 # im Menue eintagen
			list.append("								")				# Leerzeile im Menue
################		Menuebaum Rolladen	   ################################		
		if len(dict_rollo)>0:	
			list.append(headingShutter)				# Trenner im Menue 
			for adresse in sorted(dict_rollo.keys ()):						 # Rollos abfragen
				status = dict_rollo[adresse].Status				#
				if status == 0.0:							# wenn Status 0.0
					str_status = "geschlossen"					# dann "GESCHLOSSEN"
				elif status == 1.0:							# wenn Status 1.0
					str_status = "offen"						# dann "OFFEN"
				else:								# sonst Behanghoehe eintragen	
					str_status = "%3i"% (status*100) + " % "			# Wert uebernehmen,Umrechnung in % und Kommastelle abschneiden
				str_Menu_Eintrag = adresse + "  -  "+ str_status			# aktueller Status fuer Menueeintrag
				list.append((_(str_Menu_Eintrag), adresse))						 # im Menue eintagen
			list.append("								")				# Leerzeile im Menue
################		Menuebaum Soll-Temp	   ###############################
		if len(dict_wandthermo)>0:	
			list.append(headingThermostat)			# Trenner im Menue			
			for adresse in sorted(dict_wandthermo.keys ()):					# Wandthermostat abfragen
				str_Menu_Eintrag = adresse + "  -  " + str(dict_wandthermo[adresse].Status) + "  C  "  # aktueller Status fuer Menueeintrag 
				list.append((_(str_Menu_Eintrag), adresse))						 # im Menue eintagen				
			list.append("								")				# Leerzeile im Menue
################		Menuebaum Temperaturen	   ############################		
		if len(dict_temperatur)>0 or len(dict_luftfeuchte)>0:
			list.append(headingTemperature)			# Trenner im Menue			
			for adresse in sorted(dict_temperatur.keys ()):					# Temperatursensoren abfragen
				str_Menu_Eintrag = adresse + "  -  " + str(dict_temperatur[adresse].Status) + "  C  "  # aktueller Status fuer Menueeintrag 
				list.append((_(str_Menu_Eintrag), adresse))						 # im Menue eintagen			
			for adresse in sorted(dict_luftfeuchte.keys ()):				   # Luftfeuchtigkeit abfragen
				str_Menu_Eintrag = adresse + "  -  " + str(dict_luftfeuchte[adresse].Status) + "  %  "  # aktueller Status fuer Menueeintrag 
				list.append((_(str_Menu_Eintrag), adresse))						 # im Menue eintagen
			list.append("								")				# Leerzeile im Menue
################		Menuebaum Verschluss	   ##############################
		if len(dict_keymatic)>0 or len(dict_drehgriff)>0 or len(dict_tuerkontakt)>0:
			list.append(headingLock)			# Trenner im Menue
			for adresse in sorted(dict_keymatic.keys ()):					  # Schaltaktoren und Dimmer (Licht) abfragen
				status = dict_keymatic[adresse].Status				#
				if not status:													  # wenn status false
					str_status = "abgeschlossen"									# dann ist Keymatic abgeschlossen
				else:								#
					str_status = "aufgeschlossen"								   # sonst ist Keymatic aufgeschlossen
					str_Menu_Eintrag = adresse + "  -  "+ str_status					# aktueller Status fuer Menueeintrag 
				list.append((_(str_Menu_Eintrag), adresse))						 # im Menue eintagen		
			for adresse in sorted(dict_drehgriff.keys ()):					 # Drehgriff abfragen
				status = dict_drehgriff[adresse].Status			#
				if status == 0:							# wenn Status 0
					str_status = "geschlossen"					# dann "GESCHLOSSEN"
				elif status == 1:							# wenn Status 1
					str_status = "gekippt"						# dann "GEKIPPT"
				elif status == 2:							# wenn Status 2
					str_status = "offen"						# dann "OFFEN"
				else:								# sonst
					str_status = "fehler"						# Fehler
				str_Menu_Eintrag = adresse + "  -  "+ str_status			# aktueller Status fuer Menueeintrag
				list.append((_(str_Menu_Eintrag), adresse))						 # im Menue eintagen
			for adresse in sorted(dict_tuerkontakt.keys ()):				   # Tuerkontakt abfragen
				status = dict_tuerkontakt[adresse].Status			# 
				if not status:							# wenn status false
					str_status = "geschlossen"									  # dann ist die Tuer geschlossen
				else:								#
					str_status = "offen"											# sonst ist die Tuer auf
				str_Menu_Eintrag = adresse + "  -  "+ str_status					# aktueller Status fuer Menueeintrag 
				list.append((_(str_Menu_Eintrag), adresse))						 # im Menue eintagen
			list.append("								")				# Leerzeile im Menue
############			   Variablen		   ##################################
		if len(dict_var)>0:
			list.append(headingVariables)			#
			for adresse in sorted(dict_var.keys ()):						   # Variablen abfragen
				str_Menu_Eintrag = adresse + "  -  " + str(dict_var[adresse].Varwert) # aktueller Status fuer Menueeintrag 
				list.append((_(str_Menu_Eintrag), adresse))						 # im Menue eintagen					
################		Menuebaum Ende		###################################


	def __init__(self, session, args = 0):									  # Vorbereitungen aktuellen Status einlesen und in Menue eintragen
		self.session = session
		list = []
		self.__buildList(list)
		Screen.__init__(self, session)										  # Aktionen definieren
		self["myMenu"] = MenuList(list)
		self["myActionMap"] = ActionMap(["SetupActions"],
		                                {
		                                        "ok": self.go,														  # Aktion bei Taste OK
		                                        "cancel": self.cancel,												  # Aktion bei Taste EXIT
		                                        "right": self.change_on,												# Aktion bei Taste RECHTS
		                                        "left": self.change_off,												# Aktion bei Taste LINKS
		                                        "5": self.change_fuenf,												 # Aktion bei Taste 5
		                                        "2": self.change_zwei,												  # Aktion bei Taste 2
		                                        "8": self.change_acht,												  # Aktion bei Taste 8
		                                        "1": self.change_eins,												  # Aktion bei Taste 1
		                                        "3": self.change_drei,												  # Aktion bei Taste 3
		                                        "4": self.change_vier,												  # Aktion bei Taste 4
		                                        "6": self.change_sechs,												 # Aktion bei Taste 6
		                                        "7": self.change_sieben,												# Aktion bei Taste 7
		                                        "9": self.change_neun,												  # Aktion bei Taste 9
		                                        "0": self.change_null							# Aktion bei Taste 0		
		                                        }, -1)

# nach Taste OK aktuelle Werte einlesen und Menue aktualisieren
	def go(self):										# nach Betaetigen von Taste ok
		list = []
		self.__buildList(list)
		self["myMenu"].setList(list)		 					# Menue neu anzeigen

# nach Taste RECHTS Aktor einschalten
	def change_on(self):
		returnValue = self["myMenu"].l.getCurrentSelection()[1]				 # aktuelle Menuezeile einlesen
		print "\n[MyMenu] returnValue: " + returnValue + "\n"				   # Debug-Ausgabe an Konsole
		if returnValue is not None:											 # wenn Wert vorhanden
			if returnValue in dict_licht:								  # wenn Wert in Dictionary Licht
				dict_licht[returnValue].Status = True					# Status auf True setzen
			elif returnValue in dict_rollo:				# wenn Wert in Dictionary Rollo
				dict_rollo[returnValue].Status = True			# Status auf True setzen
			elif returnValue in dict_wandthermo:				# wenn Wert in Dictionary Rollo
				dict_wandthermo[returnValue].Status = dict_wandthermo[returnValue].Status+0.5			# Status um 0.5 erhoehen
			elif returnValue in dict_keymatic:				# wenn Wert in Dictionary Keymatic
				dict_keymatic[returnValue].Status = True			# Status auf True setzen 
			elif returnValue in dict_var:		  			# wenn Wert in Dictionary Variablen
				dict_var[returnValue].Varwert = 1			# Status auf True setzen				
		self.go()									# Menue aktualisieren
# nach Taste LINKS Aktor ausschalten
	def change_off(self):
		returnValue = self["myMenu"].l.getCurrentSelection()[1]				 # aktuelle Menuezeile einlesen
		print "\n[MyMenu] returnValue: " + returnValue + "\n"				   # Debug-Ausgabe an Konsole
		if returnValue is not None:											 # wenn Wert vorhanden
			if returnValue in dict_licht:								  # wenn Wert in Dictionary Licht
				dict_licht[returnValue].Status = False				   # Status auf False setzen
			elif returnValue in dict_rollo:				# wenn Wert in Dictionary Rollo
				dict_rollo[returnValue].Status = False			# Status auf False setzen
			elif returnValue in dict_wandthermo:				# wenn Wert in Dictionary Rollo
				dict_wandthermo[returnValue].Status = dict_wandthermo[returnValue].Status-0.5					# Status um 0.5 reduzieren
			elif returnValue in dict_keymatic:				# wenn Wert in Dictionary Keymatic
				dict_keymatic[returnValue].Status = False		# Status auf False setzen 
			elif returnValue in dict_var:		  			# wenn Wert in Dictionary Variablen
				dict_var[returnValue].Varwert = 0			# Status auf True setzen					   
		self.go()									# Menue aktualisieren 
# nach Taste EXIT Menue schliessen
	def cancel(self):
		print "\n[MyMenu] cancel\n"											 # Debug-Ausgabe an Konsole
		self.close(None)

# nach Taste 5 Dimmer 50%
	def change_fuenf(self):
		returnValue = self["myMenu"].l.getCurrentSelection()[1]				 # aktuelle Menuezeile einlesen
		print "\n[MyMenu] returnValue: " + returnValue + "\n"				   # Debug-Ausgabe an Konsole
		if returnValue is not None:											 # wenn Wert vorhanden
			if returnValue in dict_licht:								  # wenn Wert in Dictionary Licht
				dict_licht[returnValue].Status = 0.5					 # Status auf % setzen
			elif returnValue in dict_rollo:				# wenn Wert in Dictionary Rollo
				dict_rollo[returnValue].Status = 0.5   			# Status auf % setzen
		self.go()									# Menue aktualisieren 
# nach Taste 2 Dimmer 20%
	def change_zwei(self):
		returnValue = self["myMenu"].l.getCurrentSelection()[1]				 # aktuelle Menuezeile einlesen
		print "\n[MyMenu] returnValue: " + returnValue + "\n"				   # Debug-Ausgabe an Konsole
		if returnValue is not None:											 # wenn Wert vorhanden
			if returnValue in dict_licht:								  # wenn Wert in Dictionary Licht
				dict_licht[returnValue].Status = 0.2					 # Status auf % setzen
			elif returnValue in self.dict_rollo:				# wenn Wert in Dictionary Rollo
				dict_rollo[returnValue].Status = 0.2				   	# Status auf % setzen
		self.go()									# Menue aktualisieren 
# nach Taste 8 Dimmer 80%
	def change_acht(self):
		returnValue = self["myMenu"].l.getCurrentSelection()[1]				 # aktuelle Menuezeile einlesen
		print "\n[MyMenu] returnValue: " + returnValue + "\n"				   # Debug-Ausgabe an Konsole
		if returnValue is not None:											 # wenn Wert vorhanden
			if returnValue in dict_licht:								  # wenn Wert in Dictionary Licht
				dict_licht[returnValue].Status = 0.8					 # Status auf % setzen
			elif returnValue in dict_rollo:				# wenn Wert in Dictionary Rollo
				dict_rollo[returnValue].Status = 0.8					 # Status auf % setzen
		self.go()								# Menue aktualisieren 
# nach Taste 1 Dimmer 10%
	def change_eins(self):
		returnValue = self["myMenu"].l.getCurrentSelection()[1]				 # aktuelle Menuezeile einlesen
		print "\n[MyMenu] returnValue: " + returnValue + "\n"				   # Debug-Ausgabe an Konsole
		if returnValue is not None:											 # wenn Wert vorhanden
			if returnValue in dict_licht:								  # wenn Wert in Dictionary Licht
				dict_licht[returnValue].Status = 0.1					 # Status auf % setzen
			elif returnValue in dict_rollo:				# wenn Wert in Dictionary Rollo
				dict_rollo[returnValue].Status = 0.1					 # Status auf % setzen
		self.go()								# Menue aktualisieren 
# nach Taste 3 Dimmer 30%
	def change_drei(self):
		returnValue = self["myMenu"].l.getCurrentSelection()[1]				 # aktuelle Menuezeile einlesen
		print "\n[MyMenu] returnValue: " + returnValue + "\n"				   # Debug-Ausgabe an Konsole
		if returnValue is not None:											 # wenn Wert vorhanden
			if returnValue in dict_licht:								  # wenn Wert in Dictionary Licht
				dict_licht[returnValue].Status = 0.3					 # Status auf % setzen
			elif returnValue in dict_rollo:				# wenn Wert in Dictionary Rollo
				dict_rollo[returnValue].Status = 0.3  			# Status auf % setzen
		self.go()										# Menue aktualisieren 
# nach Taste 4 Dimmer 40%
	def change_vier(self):
		returnValue = self["myMenu"].l.getCurrentSelection()[1]				 # aktuelle Menuezeile einlesen
		print "\n[MyMenu] returnValue: " + returnValue + "\n"				   # Debug-Ausgabe an Konsole
		if returnValue is not None:											 # wenn Wert vorhanden
			if returnValue in dict_licht:								  # wenn Wert in Dictionary Licht
				dict_licht[returnValue].Status = 0.4					 # Status auf % setzen
			elif returnValue in dict_rollo:				# wenn Wert in Dictionary Rollo
				dict_rollo[returnValue].Status = 0.4				   	# Status auf % setzen
		self.go()										# Menue aktualisieren 
# nach Taste 6 Dimmer 60%
	def change_sechs(self):
		returnValue = self["myMenu"].l.getCurrentSelection()[1]				 # aktuelle Menuezeile einlesen
		print "\n[MyMenu] returnValue: " + returnValue + "\n"				   # Debug-Ausgabe an Konsole
		if returnValue is not None:											 # wenn Wert vorhanden
			if returnValue in dict_licht:								  # wenn Wert in Dictionary Licht
				dict_licht[returnValue].Status = 0.6					 # Status auf % setzen
			elif returnValue in dict_rollo:				# wenn Wert in Dictionary Rollo
				dict_rollo[returnValue].Status = 0.6					 # Status auf % setzen
		self.go()								# Menue aktualisieren 
# nach Taste 7 Dimmer 70%
	def change_sieben(self):
		returnValue = self["myMenu"].l.getCurrentSelection()[1]				 # aktuelle Menuezeile einlesen
		print "\n[MyMenu] returnValue: " + returnValue + "\n"				   # Debug-Ausgabe an Konsole
		if returnValue is not None:											 # wenn Wert vorhanden
			if returnValue in dict_licht:								  # wenn Wert in Dictionary Licht
				dict_licht[returnValue].Status = 0.7					 # Status auf % setzen
			elif returnValue in dict_rollo:				# wenn Wert in Dictionary Rollo
				dict_rollo[returnValue].Status = 0.7					 # Status auf % setzen
		self.go() 								# Menue aktualisieren 
# nach Taste 9 Dimmer 90%
	def change_neun(self):
		returnValue = self["myMenu"].l.getCurrentSelection()[1]				 # aktuelle Menuezeile einlesen
		print "\n[MyMenu] returnValue: " + returnValue + "\n"				   # Debug-Ausgabe an Konsole
		if returnValue is not None:											 # wenn Wert vorhanden
			if returnValue in dict_licht:								  # wenn Wert in Dictionary Licht
				dict_licht[returnValue].Status = 0.9					 # Status auf % setzen
			elif returnValue in dict_rollo:				# wenn Wert in Dictionary Rollo
				dict_rollo[returnValue].Status = 0.9					 # Status auf % setzen
		self.go() 								# Menue aktualisieren
# nach Taste 0 Keymatic oeffnen
	def change_null(self):
		returnValue = self["myMenu"].l.getCurrentSelection()[1]				 # aktuelle Menuezeile einlesen
		print "\n[MyMenu] returnValue: " + returnValue + "\n"				   # Debug-Ausgabe an Konsole
		if returnValue is not None:											 # wenn Wert vorhanden
			if returnValue in dict_keymatic:							   # wenn Wert in Dictionary Keymatic
				dict_keymatic[returnValue].Status2 = True				# Status auf True setzen		
##Main-Programm#########################################################################
def main(session, **kwargs):
	print "\n[MyMenu] start\n"												 # Debug-Ausgabe an Konsole
	session.open(MyMenu)
##Eintrag in Erweiterungsmenue#########################################################################
def Plugins(**kwargs):
	return PluginDescriptor(
	        name="HomeMatic V0.6",
	        description="Bedienung HM",
	        where = PluginDescriptor.WHERE_PLUGINMENU,							  # Eintrag in Erweiterungsmenue
	        icon="homematic_logo_small.png",
	        fnc=main)


Skin bei Zeile 258-262

Wer kann mir da helfen, oder mir was zum lesen empfehlen

Gruß teejay

Dateianhang:
png screenshot.png (43,46 KB, 234 mal heruntergeladen)


__________________
Drembox 900 UHD mit Merlin + GP3 - Dreambox 8000 HD mit NN² - Vu Duo² mit Vti - Vu Solo² mit Vti - DBox 1 mit DVB2000
T90= 28,2 - 23,5 - 19,2 - 16,0 - 13,0 - 9,0 - Kabel UM
08.02.2017 21:34 teejay ist offline E-Mail an teejay senden Beiträge von teejay suchen Nehmen Sie teejay in Ihre Freundesliste auf
Baumstruktur | Brettstruktur
Gehe zu:
Neues Thema erstellen Antwort erstellen
i-have-a-dreambox.com | Dreambox - Support » ...::: Skins :::... » Skin Workshop (Enigma2) » Homematic Plugin skinnen

Impressum | Team | Suchen | Hilfe


Powered by Burning Board 2.3.6 © 2001-2003 WoltLab GbR