Ankündigung

**freak83** · 09.12.2013, 08:23

Meines Wissens nicht direkt was willst du den genau machen?

**MatthiasS** · 09.12.2013, 09:04

Geht schon: in einen Logikbaustein packen.

**michaeldamm2** · 09.12.2013, 18:47

Sollte nur den samsung tv auf stumm schalten wenn jemand klingel!

den code werde !

import socket
import base64
import time, datetime
import argparse

from argparse import ArgumentParser

parser = ArgumentParser()

# Add more options if you like
parser.add_argument("-key", "--key", dest="key",
help="write report to FILE", metavar="FILE")
parser.add_argument("-myip", "--myip", dest="myip",
help="write report to FILE", metavar="FILE")

parser.add_argument("-tv", "--tv", dest="tvip",
help="write report to FILE", metavar="FILE")

parser.add_argument("-mc", "--mc", dest="mymac",
help="write report to FILE", metavar="FILE")

parser.add_argument("-q", "--quiet",
action="store_false", dest="verbose", default=True,
help="don't print status messages to stdout")

args = parser.parse_args()

print(args.key)

tvip = '192.168.0.99'

myip = '192.168.0.7'

mymac = 'xxxxxxx'

#What the iPhone app reports
appstring = "iphone..iapp.samsung"
#Might need changing to match your TV type
tvappstring = "iphone.UE55C8000.iapp.samsung"
#What gets reported when it asks for permission
remotename = "Python Samsung Remote"

# Function to send keys
def sendKey(skey, dataSock, appstring):
messagepart3 = chr(0x00) + chr(0x00) + chr(0x00) + chr(len(
base64.b64encode(skey))) + chr(0x00) + base64.b64encode(skey);
part3 = chr(0x00) + chr(len(appstring)) + chr(0x00) \
+ appstring + chr(len(messagepart3)) + chr(0x00) + messagepart3
dataSock.send(part3);

# Open Socket
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((tvip, 55000))

# First configure the connection
ipencoded = base64.b64encode(myip)
macencoded = base64.b64encode(mymac)
messagepart1 = chr(0x64) + chr(0x00) + chr(len(ipencoded)) \
+ chr(0x00) + ipencoded + chr(len(macencoded)) + chr(0x00) \
+ macencoded + chr(len(base64.b64encode(remotename))) + chr(0x00) \
+ base64.b64encode(remotename)

part1 = chr(0x00) + chr(len(appstring)) + chr(0x00) + appstring \
+ chr(len(messagepart1)) + chr(0x00) + messagepart1
sock.send(part1)

messagepart2 = chr(0xc8) + chr(0x00)
part2 = chr(0x00) + chr(len(appstring)) + chr(0x00) + appstring \
+ chr(len(messagepart2)) + chr(0x00) + messagepart2
sock.send(part2)

sendKey('KEY_MUTE',sock,tvappstring)

sock.close()

wenn jemand mir so eine logik machen könnte?

Danke

**ThorstenW** · 09.12.2013, 20:57

Hallo,

Warum nimmst du nicht den fertigen Baustein 11881 von Knet? Zu finden hier im Downloadbereich??

Gruß Thorsten

**michaeldamm2** · 10.12.2013, 06:27

Weil die Funktion Mute nur mit der registrierten Version funktioniert!

**gaert** · 10.12.2013, 09:45

Wie wäre es mit registrieren?!

**drego** · 10.12.2013, 15:36

@mathias
Kannst du mal verraten , wir man Python integrieren kann. Interessiert mich auch brennnd

Gesendet von meinem iPhone mit Tapatalk

**MatthiasS** · 10.12.2013, 15:48

https://github.com/knxuf

**michaeldamm2** · 10.12.2013, 18:50

Ich verstehe glaube es einfach nicht!!

**michaeldamm2** · 15.12.2013, 20:24

Wo ist den der fehler bei der logik?

# -*- coding: iso8859-1 -*-
## -----------------------------------------------------
## Logik-Generator V1.5
## -----------------------------------------------------
## Copyright © 2012, knx-user-forum e.V, All rights reserved.
##
## This program is free software; you can redistribute it and/or modify it under the terms
## of the GNU General Public License as published by the Free Software Foundation; either
## version 3 of the License, or (at your option) any later version.
##
## This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
## without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
## See the GNU General Public License for more details.
##
## You should have received a copy of the GNU General Public License along with this program;
## if not, see <http://www.gnu.de/documents/gpl-3.0.de.html>.

### USAGE: python.exe LogikGenerator.py [--debug --en1=34 --en2="TEST"]

import sys
import codecs
import os
import base64
import marshal
import re
try:
from hashlib import md5
except ImportError:
import md5 as md5old
md5 = lambda x='': md5old.md5(x)
import inspect
import time
import socket
import tempfile
import zlib
import zipfile

##############
### Config ###
##############

## Name der Logik
LOGIKNAME="samsung"
## Logik ID
LOGIKID="999999"

## Ordner im GLE
LOGIKCAT="michael"

## Beschreibung
LOGIKDESC="""
Samsung tv
"""
VERSION="V1.001"

## Bedingung wann die kompilierte Zeile ausgeführt werden soll
BEDINGUNG="EN[1] or EN[2] or EN[3] or EI"
## Formel die in den Zeitspeicher geschrieben werden soll
ZEITFORMEL=""
## Nummer des zu verwenden Zeitspeichers
ZEITSPEICHER="0"

## AUF True setzen um Binären Code zu erstellen
doByteCode=False
#doByteCode=True

## Base64Code über SN[x] cachen
doCache=False

## Doku erstellen Ja/Nein
doDoku=True

debug=False
livedebug=False

showList=False
#############################
########## Logik ############
#############################
LOGIK = '''# -*- coding: iso8859-1 -*-
## -----------------------------------------------------
## '''+ LOGIKNAME +''' ### '''+VERSION+'''
##
## erstellt am: '''+time.strftime("%Y-%m-%d %H:%M")+'''
## -----------------------------------------------------
## Copyright © '''+ time.strftime("%Y") + ''', knx-user-forum e.V, All rights reserved.
##
## Dieses Werk ist unter einem Creative Commons Namensnennung-Weitergabe unter gleichen Bedingungen 3.0 Deutschland Lizenzvertrag lizenziert.
## Um die Lizenz anzusehen, gehen Sie bitte zu Creative Commons ? Namensnennung - Weitergabe unter gleichen Bedingungen 3.0 Deutschland ? CC BY-SA 3.0 DE
## oder schicken Sie einen Brief an Creative Commons, 171 Second Street, Suite 300, San Francisco, California 94105, USA.

## -- ''' +re.sub("\n","\n## -- ",LOGIKDESC)+ '''

#5000|"Text"|Remanent(1/0)|Anz.Eingänge|.n.|Anzahl Ausgänge|.n.|.n.
#5001|Anzahl Eingänge|Ausgänge|Offset|Speicher|Berechnung bei Start
#5002|Index Eingang|Default Wert|0=numerisch 1=alphanummerisch
#5003|Speicher|Initwert|Remanent
#5004|ausgang|Initwert|runden binär (0/1)|typ (1-send/2-sbc)|0=numerisch 1=alphanummerisch
##5012|abbruch bei bed. (0/1)|bedingung|formel|zeit|pin-ausgang|pin-offset|pin-speicher|pin-neg.ausgang

5000|"'''+LOGIKCAT+'''\\'''+LOGIKNAME+'''_'''+VERS ION+'''"|0|5|"E1 IP TV"|"E2 IP HS"|"E3 MUTE"|"E4 1"|"E3 2"|2|"A1 Daten"|"A2 SystemLog"

5001|5|2|0|1|1

# EN[x]
5002|1|"1"|1 #* IP TV
5002|2|"1"|1 #* IP HS
5002|3|"0"|0 #* MUTE
5002|4|"0"|0 #* 1
5002|5|"0"|0 #* 2

# Speicher
5003|1||0 #* logic

# Ausgänge
5004|1|""|0|1|1 #* Daten
5004|2|""|0|1|1 #* SystemLog

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

'''
#####################
#### Python Code ####
#####################
code=[]

code.append([0,"EI",r"""
## KNXUF_XMLScrollList
if EI==1:
import zlib

class KNXUF_XMLScrollList:
def __init__(self,localvars):
EN = localvars['EN']

self.__Version__ = '""" +VERSION+ """'

self.__curPos = 0
self.__numoutputs = EN[2]

self.__lastUsed = 0

self.__List = []
self.DirectConnect = [ [ [] ] ,0 ]

self.EmptyLine = ""
self.triggerRegex = [False,False]

self.showRegex = False

import socket
import base64
import time, datetime
import argparse

from argparse import ArgumentParser

parser = ArgumentParser()

parser.add_argument('-key', '--key', dest='key',
help="write report to FILE", metavar="FILE")
parser.add_argument('-myip', '--myip', dest='myip',
help="write report to FILE", metavar="FILE")

parser.add_argument('-tv', '--tv', dest='tvip',
help="write report to FILE", metavar="FILE")

parser.add_argument('-mc', '--mc', dest='mymac',
help="write report to FILE", metavar="FILE")

parser.add_argument('-q', '--quiet',
action="store_false", dest="verbose", default=True,
help="don't print status messages to stdout")

#args = parser.parse_args()

tvip = '192.168.0.99'

myip = '192.168.0.7'

mymac = '00:0A:B3:02:29:FB'

print('senden dfdfdfd')

#What the iPhone app reports
appstring = 'iphone..iapp.samsung'
#Might need changing to match your TV type
tvappstring = 'iphone.UE55C8000.iapp.samsung'
#What gets reported when it asks for permission
remotename = "Python Samsung Remote"

# Function to send keys
def sendKey(self,skey, dataSock, appstring):

messagepart3 = chr(0x00) + chr(0x00) + chr(0x00) + chr(len(
base64.b64encode(skey))) + chr(0x00) + base64.b64encode(skey);
part3 = chr(0x00) + chr(len(appstring)) + chr(0x00) \
+ appstring + chr(len(messagepart3)) + chr(0x00) + messagepart3
dataSock.send(part3);

# Open Socket
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((tvip, 55000))

# First configure the connection
ipencoded = base64.b64encode(myip)
macencoded = base64.b64encode(mymac)
messagepart1 = chr(0x64) + chr(0x00) + chr(len(ipencoded)) \
+ chr(0x00) + ipencoded + chr(len(macencoded)) + chr(0x00) \
+ macencoded + chr(len(base64.b64encode(remotename))) + chr(0x00) \
+ base64.b64encode(remotename)

part1 = chr(0x00) + chr(len(appstring)) + chr(0x00) + appstring \
+ chr(len(messagepart1)) + chr(0x00) + messagepart1
sock.send(part1)

messagepart2 = chr(0xc8) + chr(0x00)
part2 = chr(0x00) + chr(len(appstring)) + chr(0x00) + appstring \
+ chr(len(messagepart2)) + chr(0x00) + messagepart2
sock.send(part2)

#sendKey(self,'KEY_MUTE',sock,tvappstring)

sock.close()

"""])
dbgcode="""
"""

postlogik=[0,"","""

## Klasse definieren
5012|0|"EI"|"KNXUF_XMLScrollList(locals())"|""|0|0 |1|0

5012|0|"(EI or OC[1] or EC[1]) and len(EN[2])>0"|"SN[1].sendKey(self,"KEY_MUTE",sock,tvappstring)"|""|0|0 |0|0

"""]

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

################################################## #
############## Interne Funktionen #################
################################################## #

LGVersion="1.5"

livehost=""
liveport=0
doSend=False
noexec=False
nosource=False
doZip=False
for option in sys.argv:
if option.find("--new")==0:
try:
LOGIKID=int(option.split("=")[1].split(":")[0])
LOGIKNAME=option.split("=")[1].split(":")[1]
try:
LOGIKCAT=option.split("=")[1].split(":")[2]
except:
pass
except:
print "--new=id:name[:cat]"
raise
sys.exit(1)

if LOGIKID >99999 or LOGIKID == 0:
print "invalid Logik-ID"
sys.exit(1)

if LOGIKID <10000:
LOGIKID+=10000
LOGIKID="%05d" % LOGIKID
f=open(inspect.currentframe().f_code.co_filename,' r')
data=""
while True:
line = f.readline()
if line.find("LOGIKID=") == 0:
line = "LOGIKID=\""+LOGIKID+"\"\n"
if line.find("LOGIKNAME=") == 0:
line = "LOGIKNAME=\""+LOGIKNAME+"\"\n"
if line.find("LOGIKCAT=") == 0:
line = "LOGIKCAT=\""+LOGIKCAT+"\"\n"
data += line
if not line:
break
f.close()
open(str(LOGIKID)+"_"+LOGIKNAME+".py",'w').write(d ata)
sys.exit(0)

if option=="--list":
showList=True

if option=="--debug":
debug=True

if option=="--noexec":
noexec=True

if option=="--nosource":
nosource=True

if option=="--zip":
doZip=True

if option=="--nocache":
doCache=False

if option.find("--live")==0:
livedebug=True
debug=True
doByteCode=False
doCache=True
try:
livehost=option.split("=")[1].split(":")[0]
liveport=int(option.split("=")[1].split(":")[1])
except:
print "--live=host

ort"

if option.find("--send")==0:
doSend=True
try:
livehost=option.split("=")[1].split(":")[0]
liveport=int(option.split("=")[1].split(":")[1])
except:
print "--send=host

ort"

print "HOST: "+livehost+" Port:" +str(liveport)
### DEBUG ####
EI=True
EA=[]
EC=[]
EN=[]
SA=[]
SC=[]
SN=[]
AA=[]
AC=[]
AN=[]
OC=[]
ON=[]
if debug or doSend:
EA.append(0)
EC.append(False)
EN.append(0)
AA.append(0)
AC.append(False)
AN.append(0)
SA.append(0)
SC.append(False)
SN.append(0)
ON.append(0)
OC.append(False)

## Initialisieren ##
for logikLine in LOGIK.split("\n"):
if logikLine.find("5001") == 0:
for i in (range(0,int(logikLine.split("|")[3]))):
ON.append(0)
OC.append(False)
if logikLine.find("5002") == 0:
EN.append(logikLine.split("|")[2].replace('\x22',''))
EA.append(logikLine.split("|")[2])
EC.append(False)
if logikLine.find("5003") == 0:
if logikLine.split("|")[3][0] == "1":
SN.append(re.sub('"','',logikLine.split("|")[2]))
else:
try:
SN.append(int(logikLine.split("|")[2]))
except:
pass
SN.append(logikLine.split("|")[2])
SA.append(logikLine.split("|")[2])
SC.append(False)
if logikLine.find("5004") == 0:
AN.append(logikLine.split("|")[2])
AA.append(logikLine.split("|")[2])
AC.append(False)

def bool2Name(b):
if int(b)==1:
return "Ja"
else:
return "Nein"
def sbc2Name(b):
if int(b)==1:
return "Send"
else:
return "Send By Change"

def addInputDoku(num,init,desc):
return '<tr><td class="log_e1">Eingang '+str(num)+'</td><td class="log_e2">'+str(init)+'</td><td class="log_e3">'+str(desc)+'</td></tr>\n'
def addOutputDoku(num,sbc,init,desc):
return '<tr><td class="log_a1">Ausgang '+str(num)+' ('+sbc2Name(sbc)+')</td><td class="log_a2">'+str(init)+'</td><td class="log_a3">'+str(desc)+'</td></tr>\n'

LOGIKINHTM=""
LOGIKOUTHTM=""

i=0
LEXPDEFINELINE=LHSDEFINELINE=LINDEFINELINE=LSPDEFI NELINE=LOUTDEFINELINE=0
for logikLine in LOGIK.split("\n"):
if logikLine.find("5000") == 0:
LEXPDEFINELINE=i
LOGIKREMANT=bool2Name(logikLine.split("|")[2])
LOGIKDEF=logikLine
if logikLine.find("5001") == 0:
LHSDEFINELINE=i
ANZIN=int(logikLine.split("|")[1])
ANZOUT=int(logikLine.split("|")[2])
ANZSP=int(logikLine.split("|")[4])
CALCSTARTBOOL=logikLine.split("|")[5]
CALCSTART=bool2Name(CALCSTARTBOOL)
if logikLine.find("5002") == 0:
LINDEFINELINE=i
desc=re.sub('"','',LOGIKDEF.split("|")[3+int(logikLine.split("|")[1])])
if logikLine.find("#*") >0:
desc=logikLine.split("#*")[1]
LOGIKINHTM+=addInputDoku(logikLine.split("|")[1],logikLine.split("|")[2],desc)
if logikLine.find("5003") == 0 or logikLine.find("# Speicher") == 0:
LSPDEFINELINE=i
if logikLine.find("5004") == 0:
LOUTDEFINELINE=i
desc=re.sub('"','',LOGIKDEF.split("|")[(4+ANZIN+int(logikLine.split("|")[1]))])
if logikLine.find("#*") >0:
desc=logikLine.split("#*")[1]
LOGIKOUTHTM+=addOutputDoku(logikLine.split("|")[1],logikLine.split("|")[4],logikLine.split("|")[2],desc)
i=i+1

if livedebug:
EC.append(0)
EN.append("")

sendVars=""

for option in sys.argv:
if option.find("--sa") == 0:
SA[int(option[4

ption.find("=")])]=option.split("=")[1]
sendVars+="SA["+str(int(option[4

ption.find("=")]))+"]="+option.split("=")[1]+"\n"
if option.find("--sn") == 0:
SN[int(option[4

ption.find("=")])]=option.split("=")[1]
SC[int(option[4

ption.find("=")])]=True
sendVars+="SN["+str(int(option[4

ption.find("=")]))+"]="+option.split("=")[1]+"\n"
sendVars+="SC["+str(int(option[4

ption.find("=")]))+"]=1\n"
if option.find("--aa") == 0:
AA[int(option[4

ption.find("=")])]=option.split("=")[1]
sendVars+="AA["+str(int(option[4

ption.find("=")]))+"]="+option.split("=")[1]+"\n"
if option.find("--an") == 0:
AN[int(option[4

ption.find("=")])]=option.split("=")[1]
AC[int(option[4

ption.find("=")])]=True
sendVars+="AN["+str(int(option[4

ption.find("=")]))+"]="+option.split("=")[1:]+"\n"
sendVars+="AC["+str(int(option[4

ption.find("=")]))+"]=1\n"
if option.find("--ea") == 0:
EA[int(option[4

ption.find("=")])]=option.split("=")[1]
sendVars+="EA["+str(int(option[4

ption.find("=")]))+"]="+option.split("=")[1:]+"\n"
if option.find("--en") == 0:
EN[int(option[4

ption.find("=")])]="".join(option.split("=",1)[1])
EC[int(option[4

ption.find("=")])]=True
sendVars+="EN["+str(int(option[4

ption.find("=")]))+"]="+"".join(option.split("=")[1:])+"\n"
sendVars+="EC["+str(int(option[4

ption.find("=")]))+"]=1\n"
if option.find("--ec") == 0:
# EC[int(option[4

ption.find("=")])]=int(option.split("=")[1])
sendVars+="EC["+str(int(option[4

ption.find("=")]))+"]="+option.split("=")[1]+"\n"
print sendVars
if option.find("--sc") == 0:
# EC[int(option[4

ption.find("=")])]=int(option.split("=")[1])
sendVars+="SC["+str(int(option[4

ption.find("=")]))+"]="+option.split("=")[1]+"\n"
print sendVars
if option.find("--on") == 0:
ON[int(option[4

ption.find("=")])]=option.split("=")[1]
sendVars+="ON["+str(int(option[4

ption.find("=")]))+"]="+option.split("=")[1]+"\n"
if option.find("--oc") == 0:
OC[int(option[4

ption.find("=")])]=True
sendVars+="OC["+str(int(option[4

ption.find("=")]))+"]=1\n"
if option.find("--ei") == 0:
EI=(int(option.split("=")[1])==1)
sendVars+="EI=1\n"
if option.find("--run") == 0:
sendVars+="eval(SN["+str(ANZSP+1)+"])\n"

def symbolize(LOGIK,code):
symbols = {}
for i in re.findall(r"(?m)^500([234])[|]([0-9]{1,}).*[@][@](.*)\s", LOGIK):
varName=((i[0]=='2') and 'E') or ((i[0]=='3') and 'S') or ((i[0]=='4') and 'A')
isunique=True
try:
type(symbols[i[2]])
sym=i[2]
isunique=False
except KeyError:
pass
## überprüft auch die alternativen Varianten
if re.match("[ACN]",i[2][-1:]):
try:
type(symbols[i[2][:-1]])
sym=i[2][:-1]
isunique=False
except KeyError:
pass
if isunique:
symbols[i[2]]=[varName,"["+i[1]+"]"]
else:
print "Variablen Kollision :" +repr(i[2])+" ist in " +repr(symbols[sym]) + " und "+ varName +"["+i[1]+"] vergeben"
sys.exit(1)

## Symbole wieder entfernen
LOGIK=re.sub("[@][@]\w+", "",LOGIK)

#im Code tauschen
for i in symbols.keys():
code=[code[0],re.sub("[\@][\@]"+i+"([ACN])",symbols[i][0]+"\\1"+symbols[i][1],code[1]),re.sub("[\@][\@]"+i+"([ACN])",symbols[i][0]+"\\1"+symbols[i][1],code[2])]
code=[code[0],re.sub("[\@][\@]"+i+"",symbols[i][0]+"N"+symbols[i][1],code[1]),re.sub("[\@][\@]"+i+"",symbols[i][0]+"N"+symbols[i][1],code[2])]
return LOGIK,code

NCODE=[]
commentcode=[]
for codepart in code:
NLOGIK,codepart=symbolize(LOGIK,codepart)

NCODE.append(codepart)

if codepart[0]==0 or codepart[0]==3:
commentcode.append("##########################\n## #### Quelltext: ########\n##########################"+"\n##".join( codepart[2].split("\n"))+"\n")
#else:
# commentcode.append("#"+codepart[2].split("\n")[1]+"\n################################\n## Quelltext nicht Öffentlich ##\n################################")

NLOGIK,postlogik = symbolize(LOGIK,postlogik)
LOGIK=NLOGIK

code=NCODE

## Doku
doku = """
<html>
<head><title></title></head>
<link rel="stylesheet" href="style.css" type="text/css">
<body><div class="titel">"""+LOGIKNAME+"""</div>
<div class="nav"><A HREF="index.html">Hilfe</A> / <A HREF="logic.html">Logik</A> / """+LOGIKNAME+""" / <A HREF="#anker1">Eingänge</A> / <A HREF="#anker2">Ausgänge</A></div><div class="field0">Funktion</div>
<div class="field1">"""+re.sub("\r\n|\n","<br>",LOGIKDE SC.decode("iso-8859-1").encode("ascii","xmlcharrefreplace") )+"""</div>
<div class="field0">Eingänge</div>
<a name="anker1" /><table border="1" width="612" class="log_e" cellpadding="0" cellspacing="0">
<COL WIDTH=203><COL WIDTH=132><COL WIDTH=275>
<tr><td>Eingang</td><td>Init</td><td>Beschreibung</td></tr>
"""+LOGIKINHTM.decode("iso-8859-1").encode("ascii","xmlcharrefreplace") +"""
</table>
<div class="field0">Ausgänge</div>
<a name="anker2" /><table border="1" width="612" class="log_a" cellpadding="0" cellspacing="0">
<COL WIDTH=203><COL WIDTH=132><COL WIDTH=275>
<tr><td>Ausgang</td><td>Init</td><td>Beschreibung</td></tr>
"""+LOGIKOUTHTM.decode("iso-8859-1").encode("ascii","xmlcharrefreplace") +"""
</table>
<div class="field0">Sonstiges</div>
<div class="field1">Neuberechnung beim Start: """+CALCSTART+"""<br />Baustein ist remanent: """+LOGIKREMANT+"""<br />Interne Bezeichnung: """+LOGIKID+"""<br />Der Baustein wird im "Experten" in der Kategorie '"""+LOGIKCAT+"""' einsortiert.<br /></div>
</body></html>

"""

if doDoku:
open("log"+LOGIKID+".html",'w').write(doku)

LIVECODE="""
if EN["""+str(ANZIN+1)+"""].find("<id"""+LOGIKID+""">")!=-1:
print "LivePort " +str(len(EN["""+str(ANZIN+1)+"""]))+ " Bytes erhalten"
try:
__LiveDebugCode_="".join(__import__('re').findall( "(?i)<id"""+LOGIKID+""">(.*)</id"""+LOGIKID+""">",EN["""+str(ANZIN+1)+"""]))
print "LiveDebug-Daten ID:"""+LOGIKID+" Name:"+LOGIKNAME+""" "
except:
pass
print "Fehler Datenlesen"
__LiveDebugCode_=''
if __LiveDebugCode_.find("<inject>") != -1:
SN["""+str(ANZSP+2)+"""]+="".join(__import__('re').findall("(?i)<inject> ([A-Za-z0-9\\x2B\\x3D\\x2F]+?)</inject>", __LiveDebugCode_))
print "Daten erhalten Buffer: " + str(len(SN["""+str(ANZSP+2)+"""]))
elif __LiveDebugCode_.find("<compile />") != -1:
print "Compile"
try:
__LiveBase64Code_=__import__('base64').decodestrin g(SN["""+str(ANZSP+2)+"""])
print __LiveBase64Code_
except:
pass
print "Base64 Error"
raise
try:
SN["""+str(ANZSP+1)+"""]=compile(__LiveBase64Code_,'<LiveDebug_"""+LOGIKID +""">','exec')
SC["""+str(ANZSP+1)+"""]=1
print "Running"
except:
pass
SN["""+str(ANZSP+1)+"""]="0"
SC["""+str(ANZSP+1)+"""]=1
print "Compile Error"

SN["""+str(ANZSP+2)+"""]=''
elif __LiveDebugCode_.find("<vars>") == 0:
print "Run Script"
try:
__LiveBase64Code_=__import__('base64').decodestrin g("".join(__import__('re').findall("(?i)<vars>([A-Za-z0-9\\x2B\\x3D\\x2F]+?)</vars>", __LiveDebugCode_)))
except:
pass
print "Script Base64 Error"
__LiveBase64Code_='0'
try:
eval(compile(__LiveBase64Code_,'<LiveDebugVars"""+ LOGIKID+""">','exec'))
except:
print "Script Error"
print __LiveBase64Code_
print __import__('traceback').print_exception(__import__ ('sys').exc_info()[0],__import__('sys').exc_info()[1],__import__('sys').exc_info()[2])
raise
else:
print "unbekanntes TAG: " + repr(__LiveDebugCode_)
"""

#print LIVECODE

LOGIKFILE=LOGIKID+"_"+LOGIKNAME

## Debug Lines
NCODE=[]
if debug or livedebug:
for codepart in code:
codepart[2]=re.sub("###DEBUG###","",codepart[2])
NCODE.append(codepart)
code=NCODE

#print "\n".join(code)
def commentRemover(code):
## Komentar Remover
## thanks to gaston
codelist=code[2].split("\n")
removelist=[]
lencode=len(codelist)-1
for i in range(1,lencode):
codeline=codelist[lencode-i].lstrip(" \t")
if len(codeline)>0:
if codeline[0]=='#':
removelist.insert(0,"REMOVED: ("+str(lencode-i)+") "+codelist.pop(lencode-i))
else:
codelist.pop(lencode-i)
return ([code[0],code[1],"\n".join(codelist)],"\n".join(removelist))

Nremoved=""
NCode=[]
for codepart in code:
codepart, removed=commentRemover(codepart)
Nremoved=Nremoved+removed
NCode.append(codepart)

code=NCode

#print Nremoved
#print "\n\n"

#print code

if livedebug:
NCODE="\n##### VERSION #### %04d-%02d-%02d %02d:%02d:%02d ###\n" % time.localtime()[:6]
code.append(NCODE)

CODELENGTH=len(repr(code))

breakStart=str((int(CALCSTARTBOOL)-1)*-1)
LOGIKARRAY=LOGIK.split("\n")
lformel=""
def compileMe(code,doByteCode,BEDINGUNG=''):
if doByteCode:
data=compile(code,"<"+LOGIKFILE+">","exec")
data=marshal.dumps(data)
version = sys.version[:3]
formel = ""
if doByteCode==2:
formel += "5012|0|\""+BEDINGUNG+"\"|\"eval(__import__('marsh al').loads(__import__('zlib').decompress(__import_ _('base64').decodestring('"+re.sub("\n","",base64. encodestring(zlib.compress(data,6)))+"'))))\"|\""+ ZEITFORMEL+"\"|0|"+ZEITSPEICHER+"|0|0"
else:
formel += "5012|0|\""+BEDINGUNG+"\"|\"eval(__import__('marsh al').loads(__import__('base64').decodestring('"+re .sub("\n","",base64.encodestring(data))+"')))\"|\" "+ZEITFORMEL+"\"|0|"+ZEITSPEICHER+"|0|0"
formel+="\n"

else:
if doCache:
LOGIKDEFARRAY=LOGIKARRAY[LHSDEFINELINE].split("|")
if livedebug:
LOGIKDEFARRAY[4]=str(ANZSP+2)
else:
LOGIKDEFARRAY[4]=str(ANZSP+1)
LOGIKARRAY[LHSDEFINELINE]="|".join(LOGIKDEFARRAY)
LOGIKARRAY[LSPDEFINELINE]+="\n"+"5003|"+str(ANZSP+1)+"|\"0\"|0 # Base64 Code-Cache"
if livedebug:
LOGIKARRAY[LSPDEFINELINE]+="\n"+"5003|"+str(ANZSP+2)+"|\"\"|0 # LivePortBase64Buffer"
if livedebug:
formel = "5012|0|\"EI or EC["+str(ANZIN+1)+"]\"|\"eval(compile(__import__('base64').decodestrin g('"+re.sub("\n","",base64.encodestring(LIVECODE)) +"'),'<"+LOGIKFILE+">','exec'))\"|\"\"|0|0|0|0\ n"
#formel += "5012|0|\"("+BEDINGUNG+") or SC["+str(ANZSP+1)+"]\"|\"eval(SN["+str(ANZSP+1)+"])\"|\""+ZEITFORMEL+"\"|0|"+ZEITSPEICHER+"|0|0"
formel += "5012|0|\"\"|\"eval(SN["+str(ANZSP+1)+"])\"|\""+ZEITFORMEL+"\"|0|"+ZEITSPEICHER+"|0|0"
else:
formel = "5012|0|\"EI\"|\"compile(__import__('base64').deco destring('"+re.sub("\n","",base64.encodestring(cod e))+"'),'<"+LOGIKFILE+">','exec')\"|\"\"|0|0|"+str (ANZSP+1)+"|0\n"
formel += "5012|0|\""+BEDINGUNG+"\"|\"eval(SN["+str(ANZSP+1)+"])\"|\""+ZEITFORMEL+"\"|0|"+ZEITSPEICHER+"|0|0"
else:
formel = "5012|0|\""+BEDINGUNG+"\"|\"eval(compile(__import_ _('base64').decodestring('"+re.sub("\n","",base64. encodestring(code))+"'),'<"+LOGIKFILE+">','exec')) \"|\""+ZEITFORMEL+"\"|0|"+ZEITSPEICHER+"|0|0"
#formel+="\n## MD5 der Formelzeile: "+md5.new(formel).hexdigest()
return formel

formel=""
for i in range(len(code)):
codepart=code[i]
if codepart[0]==1:
tempBC=1
if codepart[0]==2:
tempBC=2
else:
tempBC=doByteCode
if livedebug:
doCache=True
formel=compileMe(LIVECODE,False,BEDINGUNG="")
break
formel+=compileMe(codepart[2],tempBC,BEDINGUNG=codepart[1])
#formel+=commentcode[i]+"\n\n"

### DEBUG ###

formel+="\n"+postlogik[2]

## Debuggerbaustein

if livedebug:
LOGIKDEFARRAY=LOGIKARRAY[LEXPDEFINELINE].split("|")
LOGIKDEFARRAY[3]=str(ANZIN+1)
LOGIKDEFARRAY[3+ANZIN]+="|\"E"+str(ANZIN+1)+" DEBUG\""
LOGIKARRAY[LEXPDEFINELINE]="|".join(LOGIKDEFARRAY)
LOGIKDEFARRAY=LOGIKARRAY[LHSDEFINELINE].split("|")
LOGIKDEFARRAY[1]=str(ANZIN+1)
LOGIKARRAY[LHSDEFINELINE]="|".join(LOGIKDEFARRAY)
LOGIKARRAY[LINDEFINELINE]+="\n"+"5002|"+str(ANZIN+1)+"|\"\"|1 # Debugger Live in"

LOGIK = "\n".join(LOGIKARRAY)

allcode=""
for i in code:
allcode+=i[2]+"\n"

if showList:
codeobj=allcode.split("\n")
for i in range(0,len(codeobj)):
print str(i)+": "+codeobj[i]

if debug and not livedebug:
debugstart=time.clock()
allcode += debugcode
if not noexec:
exec(allcode)
else:
compile(allcode,"<code>","exec")

debugtime=time.clock()-debugstart
print "Logikausfuehrzeit: %.4f ms" % (debugtime)
if debugtime>1:
print """
###############################################
### !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ###
### !!!ACHTUNG: sehr lange Ausfürungszeit!! ###
### !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ###
###############################################
"""

if debug or doSend:
del EN[0]
del SN[0]
del AN[0]

if livedebug:
#formel=lformel
LOGIK="""############################\n#### DEBUG BAUSTEIN #######\n############################\n"""+LOGIK
livesend=re.sub("\n","",base64.encodestring(allcod e))
sock = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
sock.connect((livehost,liveport))
Livepackets=0
while livesend!="":
Livepackets+=1
sock.sendall("<xml><id"+LOGIKID+"><inject>"+livese nd[:4000]+"</inject></id"+LOGIKID+"></xml>")
livesend=livesend[4000:]
time.sleep(0.1)
time.sleep(1)
sock.sendall("<xml><id"+LOGIKID+"><compile /></id"+LOGIKID+"></xml>")
print str(Livepackets)+ " Packet per UDP verschickt"
sock.close()

if doSend:
## Das auslösen über den Debug verhindern
sendVars="EC["+str(ANZIN+1)+"]=0\n"+sendVars
sock = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
sock.connect((livehost,liveport))
sock.sendall("<xml><id"+LOGIKID+"><vars>"+re.sub(" \n","",base64.encodestring(sendVars)+"</vars></id"+LOGIKID+"></xml>\n"))
sock.close()

if VERSION !="":
VERSION="_"+VERSION
if debug:
VERSION+="_DEBUG"

open(LOGIKFILE+VERSION+".hsl",'w').write(LOGIK+"\n "+formel+"\n")
def md5sum(fn):
m = md5()
f=open(fn,'rb')
while True:
data = f.read(1024)
if not data:
break
m.update(data)
f.close()
return m.hexdigest() + " *" + fn + "\n"

#chksums = md5sum(LOGIKFILE+VERSION+".hsl")
#if not nosource:
# chksums += md5sum(inspect.currentframe().f_code.co_filename)
#if doDoku:
# chksums += md5sum("log"+LOGIKID+".html")
#
#open(LOGIKFILE+".md5",'w').write(chksums)

if doZip:
#os.remove(LOGIKFILE+VERSION+".zip")
z=zipfile.ZipFile(LOGIKFILE+VERSION+".zip" ,"w",zipfile.ZIP_DEFLATED)
if not nosource:
z.write(inspect.currentframe().f_code.co_filename)
if doDoku:
z.write("log"+LOGIKID+".html")
z.write(LOGIKFILE+VERSION+".hsl")
# z.write(LOGIKFILE+".md5")
z.close()

print "Baustein \"" + LOGIKFILE + "\" erstellt"
print "Groesse:" +str(CODELENGTH)

if livedebug:
print "########################################"
print "#### DEBUGBAUSTEIN ####"
print "########################################"

print """
Neuberechnung beim Start: """+CALCSTART+"""
Baustein ist remanent: """+LOGIKREMANT+"""
Interne Bezeichnung: """+LOGIKID+"""
Kategorie: '"""+LOGIKCAT+"""'
Anzahl Eingänge: """+str(ANZIN)+""" """+repr(EN)+"""
Anzahl Ausgänge: """+str(ANZOUT)+""" """+repr(AN)+"""
Interne Speicher: """+str(ANZSP)+""" """+repr(SN)+"""
"""

#print chksums

Ankündigung

Gira Homeserver Logik

Gira Homeserver Logik

Kommentar

Kommentar

Kommentar

Kommentar

Kommentar

Kommentar

Kommentar

Kommentar

Kommentar

Kommentar