init repo

.gitignore

@@ -0,0 +1,3 @@
+*.pyc
+__pycache__
+*.swp

ArtNetNode.py

@@ -0,0 +1,108 @@
+
+import time
+import socket
+import struct
+import random
+
+class ArtNetNode():
+    """simple Object to generate ArtNet Network packages 
+       works in Python2 and Python3  2021-12-05
+
+    """
+    def __init__(self, to="10.10.10.255",univ=7,port=6454):
+        try: 
+            univ = int(univ)
+        except:
+            print("errror univ",univ ,"is not int ... set to 7")
+            univ = 7
+        self.univ=univ
+        self.sendto = to
+        self.portto = port
+        print(__name__,"bind",to,port,univ)
+        self.s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        self.s.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
+        self.s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        self.stamp = time.time()
+        self.test_stamp = time.time()
+        self.dmx=[33]*512
+        self.v=0
+        self.d=1
+
+    def head(self):
+        self._header = []
+        self._header.append(b"Art-Net\x00")            # Name, 7byte + 0x00
+        self._header.append(struct.pack('<H', 0x5000)) # OpCode ArtDMX -> 0x5000, Low Byte first
+        self._header.append(struct.pack('>H', 14))     # Protocol Version 14, High Byte first
+        self._header.append(b"\x00")                   # Order -> nope -> 0x00
+        self._header.append(struct.pack('B',1))        # Eternity Port
+
+        # Address
+        #if 0 <= universe <= 15 and 0 <= net <= 127 and 0 <= subnet <= 15
+        net, subnet, universe = (0,0,self.univ) #address
+        self._header.append(struct.pack('<H', net << 8 | subnet << 4 | universe))
+
+        self._header = b"".join(self._header)
+
+    def send(self,dmx=None,port=''):
+        if dmx is None:
+            dmx = self.dmx
+        else:
+            self.dmx = dmx
+        self.head()
+        c=[self._header]
+
+        c.append( struct.pack('>H', len(dmx) ) )
+        #print([c])
+
+        dmx_count = 0
+        for v in dmx:
+            if type(v) is not int:
+                v=0
+            elif v > 255: # max dmx value 255
+                v = 255
+            elif v < 0: # min dmx value 0
+                v = 0
+            dmx_count += 1
+            c.append(struct.pack("B",v))
+        c = b"".join(c)
+        if port:
+            self.s.sendto(c, (self.sendto, port)) # default 6454
+        else:
+            self.s.sendto(c, (self.sendto, self.portto)) # default 6454
+        #print(self.v)
+        time.sleep(0.0001)
+        return c
+    def _test_frame(self):
+        if self.test_stamp+(.01) < time.time():
+            self.test_stamp = time.time()
+            #dmx = [0]*512
+            self.dmx[201-1] = self.v
+            #self.dmx = dmx
+            if self.v >= 255:
+                self.d=0
+            elif self.v <=0:
+                self.d=1
+
+            if self.d:
+                self.v+=1
+            else:
+                self.v-=1
+            #print( self.v)
+        #time.sleep(1/30.)
+    def next(self):
+        if self.stamp + (1/30.) < time.time():
+            self.send()
+
+def artnet_test():
+    #artnet = ArtNetNode(to="127.0.0.1",port=6555,univ=12)
+    #artnet = ArtNetNode(to="127.0.0.1",port=6555,univ=0)
+    artnet = ArtNetNode(to="10.10.10.255",univ=0)
+    #artnet = ArtNetNode(to="2.0.0.255",univ=0)
+    #artnet = ArtNetNode(to="10.10.10.255",univ=1)
+    while 1:
+        artnet._test_frame()
+        artnet.next()
+        time.sleep(0.01)
+
+if __name__ == "__main__":
+    artnet_test()

chat.py

@@ -0,0 +1,133 @@
+#! /usr/bin/python3
+# -*- coding: utf-8 -*-
+
+"""
+This file is part of grandPA.
+
+grandPA 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 2 of the License, or
+(at your option) any later version.
+
+grandPA 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 grandPA.  If not, see <http://www.gnu.org/licenses/>.
+
+(c) 2012 micha.rathfelder@gmail.com
+"""
+
+import socket
+import sys 
+import time
+
+
+class tcp_sender(object):
+    def __init__(self):
+        self.connect()
+        
+    def connect(self,client_name="unkown"):
+        self.xip = "127.0.0.1" #raw_input("IP-Adresse: ")
+        self.xs = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        try:
+            self.xs.connect((self.xip, 50000))
+        except ConnectionRefusedError as e:
+            print("ConnectionRefusedError: ", "ERR: {0} ".format(e.args) ,end="")
+            print("Server nicht ereichbar/unterbrochen")
+            time.sleep(1)
+            self.connect()
+        print("connected !")
+
+    def send(self,nachricht):
+
+        try:
+            self.xs.send(bytes(nachricht+";","utf-8") )
+        except socket.error as e:
+            self.connect()
+    def close(self):
+        self.xs.close()
+
+
+
+def dummyCB(msg):
+    print("dummy_CB",msg)
+
+
+def cmd(cb=dummyCB):
+    import socket
+    import select
+
+    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+    #self.xs.getsockopt(socket.AF_INET, socket.SO_REUSEADDR )
+
+    server.bind(("", 50000))
+    server.listen(1)
+
+    clients = []
+    clients2 = [""]*300
+    try:
+        while True:
+            lesen, schreiben, oob = select.select([server] + clients,
+                                                  [], [])
+
+            for sock in lesen:
+                if sock is server:
+                    client, addr = server.accept()
+                    clients.append(client)
+                    print("+++ Client %s verbunden" % addr[0])
+                    #sock.send("hi du")
+                else:
+                    nachricht = sock.recv(1024)
+                    nachricht = str(nachricht,"utf-8")
+                    nachrichten = nachricht.strip().replace("EOB","")
+                    if "client_name:" in nachrichten:
+                        if sock in clients:
+                            client_nr = clients.index(sock)
+                            clients2[client_nr] = nachrichten
+                    if sock in clients:
+                        client_nr = clients.index(sock)
+                        print(clients2[client_nr])
+                    ip = sock.getpeername()[0]
+                    #print(">>>", ip, nachrichten.split(";"))
+                    if nachrichten:
+                        tstamp = time.strftime("%H:%M:%S")
+
+                        print("from:",client_nr,">>>", tstamp , ip, nachrichten.split(";"))
+                        for xx,nachricht in enumerate(nachrichten.split(";")):
+                            cmd = nachricht #.split(" ")
+                            print(xx,cmd)
+                            cb({"c":client_nr,"cmd":cmd})
+
+
+                    else:
+                        print("+++ Verbindung zu %s beendet" % ip)
+                        sock.close()
+                        if sock in clients:
+                            client_nr = clients.index(sock)
+                            clients2[client_nr] = ""
+                        clients.remove(sock)
+    except KeyboardInterrupt:
+        print(" strg+c")
+    finally:
+        for c in clients:
+            print(c,"close")
+            c.close()
+        server.close()
+        print("server close")
+
+
+if __name__ == "__main__":
+    print( sys.argv ) 
+    if sys.argv[1] == "server":
+        cmd()
+    elif sys.argv[1] == "client":
+        c = tcp_sender()
+        while 1:
+            x = input(":: ")
+            c.send(x)
+
+

console.py

@@ -0,0 +1,80 @@
+#! /usr/bin/python3
+# -*- coding: utf-8 -*-
+
+"""
+This file is part of grandPA.
+
+grandPA 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 2 of the License, or
+(at your option) any later version.
+
+grandPA 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 grandPA.  If not, see <http://www.gnu.org/licenses/>.
+
+(c) 2012 micha.rathfelder@gmail.com
+"""
+
+import time
+import socket
+import struct
+import random
+ 
+import chat
+import ArtNetNode as ANN
+import _thread as thread  
+#thread.start_new_thread
+
+idmx = [0]*512 # incremental dmx
+dmx  = [0]*512 # absolute dmx data
+
+def artnet_loop():
+    #artnet = ANN.ArtNetNode(to="127.0.0.1",port=6555,univ=12)
+    #artnet = ANN.ArtNetNode(to="127.0.0.1",port=6555,univ=0)
+    artnet = ANN.ArtNetNode(to="10.10.10.255",univ=0)
+    #artnet = ANN.ArtNetNode(to="2.0.0.255",univ=0)
+    #artnet = ANN.ArtNetNode(to="10.10.10.255",univ=1)
+    dmx[205] = 255 #205 BLUE
+    artnet.dmx= dmx #[0]*512
+    artnet.send()
+    while 1:
+        #artnet._test_frame()
+        artnet.next()
+        time.sleep(0.01)
+
+thread.start_new_thread(artnet_loop,())
+def CB(data):
+    print("CB",data)
+    if "cmd" in data:
+        cmd = data["cmd"]
+        print("cmd",cmd)
+        if "," in cmd:
+            cmds = cmd.split(",")
+        else:
+            cmds = [cmd]
+        
+        for xcmd in cmds:
+            if xcmd.startswith("d"):
+                xxcmd=xcmd[1:].split(":")
+                print("DMX:",xxcmd)
+                l = xxcmd
+                try:
+                    k=int(l[0])-1
+                    v=int(l[1])
+                    if v > 255:
+                        v = 255
+
+                    if len(dmx) > k:
+                        dmx[k] = v
+                except Exception as e:
+                    print("EXCEPTION IN DMX",e)
+
+
+chat.cmd(CB)
+
+input("END")

motion.py

@@ -0,0 +1,400 @@
+#! /usr/bin/python
+# -*- coding: utf-8 -*-
+
+"""
+This file is part of grandPA.
+
+grandPA 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 2 of the License, or
+(at your option) any later version.
+
+grandPA 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 grandPA.  If not, see <http://www.gnu.org/licenses/>.
+
+(c) 2012 micha.rathfelder@gmail.com
+"""
+import math, random
+import time,json
+class Sequence(object):
+    def __init__(self):
+        pass
+    def go(self,ID,RANGE,ATTRIBUT):
+        pass
+
+class Stack(object):
+    "List of Presets"
+    def __init__(self):
+        self.__stacks = show.load_stacks(self.__show["NAME"],self.__stacks)
+
+    def save(self):
+        show.save_stacks(self.__show["NAME"],self.__stacks)
+    def __str__(self):
+        pass 
+    def go(self,ID):
+        pass
+    def pause(self,ID):
+        pass
+    def set(self,optinon,value):
+        pass
+    def next(self,FIX,ATTR):
+        pass 
+
+class Effect(object):
+    """Effect sinus, cosinus, linear"""
+    def __init__(self,TYPE="sinus",size=10,speed=100,offset=0,egroup=None,DIR=1):
+            
+        self.__type=TYPE
+        self.__msize=255
+        self.__mspeed=255
+        self.__moffset=1
+        self.__dir=DIR
+        self.__mdir=1
+        self.__size=size
+        self.__speed=speed
+        self.__base = None 
+        self.__offset = offset
+        self.__vmax = -1000000
+        self.__vmaxt = 0
+        self.__vmin = 1000000
+        self.__vmint = 0
+        if self.__offset:
+            self.__step = float(self.__offset*self.__moffset)           
+        else:
+            self.__step = 0
+        #self.__step = 0
+        self.__old_step = 0#self.__step 
+        self.__old_rand = 0 
+
+        self.__egroup = egroup
+        print(self)
+    def __str__(self):
+        return self.__repr__()
+    def __repr__(self):
+        return '<%(klass)s type:%(TYPE)s size:%(size)s base:%(base)s speed:%(speed)s offset:%(offset)s egroup:%(egroup)s msize:%(msize)s mspeed:%(mspeed)s moffset:%(moffset)s mdir:%(mdir)s _dir:%(_dir)s>' % dict(
+			klass  = self.__class__.__name__,
+			TYPE   = self.__type,
+			size   = self.__size,
+            base   = self.__base,
+			speed  = self.__speed,
+            offset = self.__offset,
+            egroup = self.__egroup,
+            msize  = self.__msize,
+            mspeed = self.__mspeed,
+            moffset = self.__moffset,
+            mdir = self.__mdir,
+            _dir = self.__dir
+		)
+    def __sinus(self,current_value):
+        
+        out = current_value + math.sin(self.__step/1000.)*self.__size*self.__msize/255  #+ self.__offset*self.__moffset/10
+        if self.__mdir:
+            if self.__dir:
+                DIR = 0
+            else:
+                DIR = 1
+        else: 
+            if self.__dir:
+                DIR = 1
+            else:
+                DIR = 0
+        #print(DIR)
+        if DIR:
+            self.__step += (self.__speed/100)*self.__mspeed/255 #+ self.__offset*self.__moffset/10
+        else:
+            #out = current_value + math.cos(self.__step/1000.)*self.__size*self.__msize/255  #+ self.__offset*self.__moffset/10
+            self.__step -= (self.__speed/100)*self.__mspeed/255 #+ self.__offset*self.__moffset/10
+    
+        if int(out) > self.__vmax:
+            self.__vmaxt = time.time()
+            self.__vmax = int(out)
+            #print("max schrittbreite ",self.__vmaxt - self.__vmint,"sec \t",self)
+        if int(out) < self.__vmin:
+            self.__vmint = time.time()
+            self.__vmin = int(out)
+            #print("min schrittbreite ",self.__vmaxt - self.__vmint,"sec \t",self)
+        if out > 255:
+            out = 255
+        elif out < 0:
+            out = 0
+        #print(self)
+        return out
+    def __cosinus(self,current_value):
+        
+        out = current_value + math.cos(self.__step/1000.)*self.__size*self.__msize/255 #+ self.__offset*self.__moffset/10
+        if self.__mdir:
+            if self.__dir:
+                DIR = 0
+            else:
+                DIR = 1
+        else: 
+            if self.__dir:
+                DIR = 1
+            else:
+                DIR = 0
+
+        #if self.__mdir + self.__dir == 1:
+        if DIR:
+            #out = current_value + math.cos(self.__step/1000.)*self.__size*self.__msize/255 #+ self.__offset*self.__moffset/10
+            self.__step += (self.__speed/100)*self.__mspeed/255 #+ self.__offset*self.__moffset/10
+        else:
+            #out = current_value + math.sin(self.__step/1000.)*self.__size*self.__msize/255 #+ self.__offset*self.__moffset/10
+            self.__step -= (self.__speed/100)*self.__mspeed/255 #+ self.__offset*self.__moffset/10
+            
+        if out > 255:
+            out = 255
+        elif out < 0:
+            out = 0
+        
+        return out
+    def __linear(self,current_value):
+        pass
+    def __rand(self,current_value):
+        #self.__step += int(self.__speed/10000)
+        #print(self.__old_step-int(self.__speed/1000.) , time.time())
+        if self.__old_step < time.time():
+            self.__old_rand =  random.randint(0,int(self.__size*self.__msize/255)  ) 
+            self.__old_step = time.time() + ( 10-  (  ( self.__speed/100. ) *self.__mspeed/255 )  / 30000.  )       
+            print("NEW SPEED :" ,self.__old_step, time.time() - self.__old_step)
+            print("NEW RAND :" ,self.__old_rand)
+        return self.__old_rand 
+    def get_egroup(self):
+        return self.__egroup        
+    def set_mdir(self, mdir):
+        if type(mdir) is int:
+            if mdir != 0:
+                mdir = 1
+            self.__mdir=mdir
+        else:
+            print(self, "mdir not an int")
+        #print(self.__mdir * self.__dir)
+    def set_msize(self,msize):
+        if type(msize) is int:
+            self.__msize=msize
+        else:
+            print(self, "msize not an int")
+    def set_mspeed(self,mspeed):
+        if type(mspeed) is int:
+            self.__mspeed=mspeed
+        else:
+            print(self, "mspeed not an int")
+
+    def set_moffset(self,moffset):
+        # set Master Offset
+        if type(moffset) is int:
+            if moffset != self.__moffset:
+                val = self.__offset*self.__moffset
+                self.__step -= float(val)            
+                #print("old offset ",val)
+                self.__moffset = moffset
+                val = self.__offset*self.__moffset
+                self.__step += float(val)            
+                #print("new offset ",val)
+                #self.__offset = float(val)    self.__moffset=moffset
+                #print("set moffset",moffset, self.__offset*self.__moffset/10)
+        else:
+            print(self, "moffset not an int")
+
+    def set_size(self,val):
+        self.__size = val
+    def set_speed(self,val):
+        self.__speed = val
+    def set_type(self,val):
+        self.__type = val
+    def set_offset(self,val):
+        self.__step -= float(self.__offset)            
+        self.__step += float(val)            
+        self.__offset = float(val)           
+    def next(self,current_value):
+        self.__base = current_value
+
+        if self.__type == "sinus":
+            return self.__sinus(current_value)            
+        elif self.__type == "cosinus":
+            return self.__cosinus(current_value)
+        elif self.__type == "linear":
+            return 0
+            pass
+        elif self.__type == "rand":
+            return self.__rand(current_value)
+        else:
+            print("effect type \""+str(self.__type) +"\" unknown")
+            return 0
+
+    
+  
+
+
+
+class FadeFast(object):
+    """Fade 16bit mode as FLOAT 
+
+    Berechnet Schritte in "on the fly"
+    """    
+    def __init__(self,start,target,fadetime=None,start_time=None):
+        self.INIT = 0 
+        if target > 255.999:
+            target = 255.999
+        elif target < 0:
+            target = 0
+        if start_time:
+            self.__start_time = start_time
+        else:
+            self.__start_time = time.time()
+        self.fakt = 1000.
+        #feine aufloesung
+        start = int(start*self.fakt)
+        target = int(target*self.fakt)
+        if not fadetime:
+            start = target
+        self.__start = start
+        self.__current = start
+        self.__target = target
+        self.__fadetime = fadetime
+        self.__dist = target - start
+        
+        #print(self.__class__.__name__,"(", self.__start/self.fakt, self.__target/self.fakt, self.__dist/self.fakt, self.__fadetime , ") NEW FADE OBJ")
+        if self.__dist != 0:
+            self.__step_time = fadetime / (self.__dist * 1.0)
+        else:
+            self.__step_time = 0
+            
+        if self.__step_time < 0:
+            self.__step_time = self.__step_time *-1
+
+        #print(self.__step_time)
+        #print(self)
+    def __dict__(self):
+        return None
+    def __str__(self):
+        return self.__repr__()
+    def __repr__(self):
+        #return {"non":None}
+        return '<%(klass)s start:%(start)s target:%(target)s fadetime:%(fadetime)ssec start_time:%(start_time)ssec>' % dict(
+			klass    = self.__class__.__name__,
+			start   = self.__start/self.fakt,
+			target = self.__target/self.fakt,
+			fadetime = self.__fadetime,
+            start_time = self.__start_time
+		) 
+
+
+    def next(self):
+        
+        jetzt = time.time()
+
+        if jetzt >= self.__fadetime + self.__start_time or not self.__step_time :
+            if not self.INIT:
+                #print(self.__fadetime,jetzt - self.__start_time)
+                #print("end")
+                self.INIT = 1
+            return self.__target/self.fakt
+
+        elif jetzt < self.__start_time:
+              return self.__start
+        if self.__step_time :
+            step = (jetzt - self.__start_time) / self.__step_time 
+        else:
+            step = 0
+        #print(self.__class__.__name__,"fade",self.__fadetime,"jetzt",jetzt,"start_t", self.__start_time,"start",self.__start,"step", step,"step_t",self.__step_time)
+        if self.__start < self.__target:
+            return int(self.__start + step)/self.fakt
+        else:
+            return int(self.__start - step)/self.fakt
+
+
+
+
+class Fade(object):
+    """altes fade objekt
+
+    Speicher fresser und initialisierung dauert
+    alle einzelschritte werden bei der initialisierung erzeugt
+    """
+
+    def __init__(self,start,target,fadetime=None,start_time=None):
+        self.INIT = 0 
+        if target > 255:
+            target = 255
+        if start_time:
+            self.__time = start_time
+        else:
+            self.__time = time.time()
+
+        #feine aufloesung
+        start = int(start*100.)
+        target = int(target*100.)
+        if not fadetime:
+            start = target
+        self.__start = start
+        self.__current = start
+        self.__target = target
+        self.__fadetime = fadetime
+        self.__dist = target - start
+        print(self.__class__.__name__,"(", self.__start/100., self.__target/100., self.__dist/100, self.__fadetime , ") NEW FADE OBJ")
+        if self.__dist != 0:
+            self.__step_time = fadetime / (self.__dist * 1.0)
+        else:
+            self.__step_time = 0
+            
+        self.__steps = []
+        
+        if self.__dist < 0: 
+            for i in range(self.__dist*-1):
+                self.__steps.append([self.__start,0])
+        elif self.__dist > 0:            
+            for i in range(self.__dist):
+                self.__steps.append([self.__start,0])            
+        else:
+            self.__steps.append([self.__target,time.time()])
+            #print("DIST == 0")
+        
+        if self.__step_time < 0:
+            self.__step_time = self.__step_time *-1
+
+            
+        i = 0 
+        #print(self#.__dist, self.__start ,self.__step_time)
+        #erstelle alle schritte mit absolutem zeitstempel
+        while self.__dist != 0:
+            if self.__dist > 0:
+               self.__current += 1
+               self.__dist -= 1
+            else:
+               self.__current -= 1
+               self.__dist += 1
+            self.__time += self.__step_time 
+            self.__steps[i][0] =  self.__current
+            self.__steps[i][1] =  self.__time
+            
+            i += 1
+        #print(i,self.__steps, self.__dist, self.__start )
+
+    def __str__(self):
+        return self.__repr__()
+    def __repr__(self):
+        return '<%(klass)s start:%(start)s target:%(target)s fadetime:%(fadetime)s sec>' % dict(
+			klass    = self.__class__.__name__,
+			start   = self.__start/100.,
+			target = self.__target/100.,
+			fadetime = self.__fadetime,
+		) 
+    def next(self):
+        out = self.__start
+        jetzt = time.time()
+        #print(self.__start,self.__steps[-1])
+        if jetzt < self.__steps[-1][1]: 
+            for i in self.__steps:
+                if jetzt >= i[1]:
+                     out = i[0]
+                     #print(i, jetzt  ,jetzt >= i[1])
+            return out /100.
+        else:
+            return self.__steps[-1][0]/100. 
+
+

send_loop.py

@@ -0,0 +1,40 @@
+import chat
+import time
+
+import motion 
+
+def inp():
+    c = chat.tcp_sender()
+    while 1:
+        x = input(":: ")
+        c.send(x)
+
+
+fx = []
+#for i in range(10):
+def loop():
+    c = chat.tcp_sender()
+    x = 0
+
+    fx1 = motion.Effect(size=30,speed=2500)
+    fx2 = motion.Effect(TYPE="cosinus",size=30,speed=2500)
+    fd1 = motion.FadeFast(start=10,target=10,fadetime=4)
+    
+    while 1:
+        xfd1= int(fd1.next())
+        #print("fd",xfd1)
+        if xfd1 == 10:
+            fd1 = motion.FadeFast(start=xfd1,target=200,fadetime=4)
+        if xfd1 == 200:
+            fd1 = motion.FadeFast(start=xfd1,target=10,fadetime=4)
+
+        x1 = int(fx1.next(50))
+        x2 = int(fx2.next(127))
+        x += 3
+        if x >= 255:
+            x=0
+        c.send("d201:{},d241:{},d243:{}".format(xfd1,x2,x1))
+        time.sleep(0.051)
+
+loop()
+#inp()