refactoring/cleanup _console

_console.py

@@ -63,9 +63,6 @@ from collections import OrderedDict
 import lib.zchat as chat
 import lib.ArtNetNode as ANN
 import _thread as thread  
-#thread.start_new_thread
-
-#import lib.motion as motion
 
 #idmx = [0]*512 # incremental dmx
 dmx  = [0]*512 # absolute dmx data
@@ -561,6 +558,7 @@ class DMXCH(object):
         self._fade  = None
         self._fx    = [None,None] # None
         self._fx_value = 0
+        self.name = "<name>"
 
         self._dmx = dmx
         self._dmx_fine = 0
@@ -651,7 +649,8 @@ class DMXCH(object):
         if type(self._last_val) in [int,float]:
             v = round(self._last_val,2)
 
-        return "<BUFFER DMX:{} FINE:{} VAL:{} EXEC:{}\n  fd:{}\n  fx:{}\n  fx_flash:{}\n".format(
+        return "<DMXCH {} DMX:{} FINE:{} VAL:{} EXEC:{}\n  fd:{}\n  fx:{}\n  fx_flash:{}\n".format(
+                    self.name,
                     self._dmx,self._dmx_fine
                     ,v,str(self._exec_ids)
                     ,self._fade
@@ -724,7 +723,9 @@ class DMXCH(object):
 V_MASTER = {} #DMXCH
 Bdmx = []
 for i in range(512*7+1):
-    Bdmx.append( DMXCH(i) )
+    xDMX = DMXCH(i) 
+    xDMX.name = "543"+str(i)
+    Bdmx.append(xDMX)
     #print(type(dmx[i]))
 
 _id = 1
@@ -855,135 +856,108 @@ htp_master = HTP_MASTER()
 
 
 
-class Main():
+class Core():
     def __init__(self):
         self.artnet = {}
         self.fx = {} # key is dmx address
         self.lock = thread.allocate_lock()
-    def loop(self):
+  
+    def _fine_loop(self,Bdmx,t):
+        old_univ = -1
         xx = [0]*512
-        ii = 0
+        for ii,dmxch in enumerate(Bdmx): #fine loop
+            dmx_fine =  dmxch._dmx_fine
+            if dmx_fine > 0:
+                i = ii%512
+                univ = ii//512
+
+                if univ != old_univ:
+                    artnet = self.artnet[str(univ)]
+                    xx = artnet.dmx# = xx
+                
+                v = dmxch.next(t)
+                vv = vdmx.by_dmx(clock=i,dmx=ii+1)
+                try:
+                    v = v*vv # disable v-master
+                except Exception as e:
+                    cprint("Exception v*vv",[v,vv],e)
+                    continue
+
+                vf = int(v%1*255)
+                dmx_fine = dmx_fine%512
+                try:
+                    if v >= 255:
+                        xx[dmx_fine-1] = 255
+                    elif v < 0:
+                        xx[dmx_fine-1] = 0
+                    else:
+                        xx[dmx_fine-1] = int(v%1*255)
+                except Exception as e:
+                    print("E dmx_fine",e,dmx_fine)
+
+    def _coarse_loop(self,Bdmx,t):
         old_univ = -1
         xx = [0]*512
         for ii,dmxch in enumerate(Bdmx):
             i = ii%512
             univ = ii//512
-            if str(univ) not in self.artnet:
-                print("add uiv",univ)
-                self.artnet[str(univ)] = ANN.ArtNetNode(to="10.10.10.255",univ=univ)
 
             if univ != old_univ:
                 old_univ = univ
-                try:
-                    artnet.next()
-                except:pass
                 artnet = self.artnet[str(univ)]
-                artnet.dmx = [0]*512
+                xx = artnet.dmx 
 
-        fps_start = time.time()
-        fps = 0
-        dbg= 0#1
-        while 1:
-            self.lock.acquire_lock()
+            v = dmxch.next(t)
+            xx[i] = int(v)
 
-            start = time.time()
-            _t=0
-            t = clock.time()
-            ii = 0
-            old_univ = -1
-            xx = [0]*512
-            for ii,dmxch in enumerate(Bdmx):
-                i = ii%512
-                univ = ii//512
-                s_univ = str(univ)
-                if s_univ not in self.artnet:
-                    print("add uiv",univ)
-                    self.artnet[s_univ] = ANN.ArtNetNode(to="10.10.10.255",univ=univ)
 
+    def artnete_init(self,Bdmx):
+        """Init artnet if not exist's
+        """
+        for ii,dmxch in enumerate(Bdmx):
+            i = ii%512
+            univ = ii//512
+            if str(univ) not in self.artnet:
+                print("add uiv",univ)
+                self.artnet[str(univ)] = ANN.ArtNetNode(to="10.10.10.255",univ=univ)
 
-            if dbg:
-                end = time.time()
-                print(" t",_t,ii,round(end-start,4))
-            start = time.time()
-            _t+=1
+    def calc_fps(self,stop_fps=50):
+        self.fps += 1
+        if self.fps >= stop_fps:
+            fps_t = time.time()
+            FPS = round(stop_fps/(fps_t-self.fps_start),2)
+            print("{:0.0f} core/fps".format(FPS) ) 
+            self.fps = 0
+            self.fps_start = time.time()
 
-            old_univ = -1
-            xx = [0]*512
-            for ii,dmxch in enumerate(Bdmx):
-                i = ii%512
-                univ = ii//512
+    def loop(self):
+        """ core artnet calculation loop
+        """
+        self.artnete_init(Bdmx)
 
-                if univ != old_univ:
-                    old_univ = univ
-                    artnet = self.artnet[str(univ)]
-                    xx = artnet.dmx 
+        self.fps_start = time.time()
+        self.fps = 0
 
-                v = dmxch.next(t)
-                xx[i] = int(v)
-
-            if dbg:
-                end = time.time()
-                print(" t",_t,ii,round(end-start,4))
-            start = time.time()
-            _t+=1
-
-            old_univ = -1
-            xx = [0]*512
-            for ii,dmxch in enumerate(Bdmx): #fine loop
-                dmx_fine =  dmxch._dmx_fine
-                if dmx_fine > 0:
-                    i = ii%512
-                    univ = ii//512
-
-                    if univ != old_univ:
-                        artnet = self.artnet[str(univ)]
-                        xx = artnet.dmx# = xx
-                    
-                    v = dmxch.next(t)
-                    vv = vdmx.by_dmx(clock=i,dmx=ii+1)
-                    try:
-                        v = v*vv # disable v-master
-                    except Exception as e:
-                        cprint("Exception v*vv",[v,vv],e)
-                        continue
-
-                    vf = int(v%1*255)
-                    dmx_fine = dmx_fine%512
-                    try:
-                        if v >= 255:
-                            xx[dmx_fine-1] = 255
-                        elif v < 0:
-                            xx[dmx_fine-1] = 0
-                        else:
-                            xx[dmx_fine-1] = int(v%1*255)
-                    except Exception as e:
-                        print("E dmx_fine",e,dmx_fine)
-            if dbg:
-                end = time.time()
-                print(" t",_t,ii,round(end-start,4))
-                print()
-            start = time.time()
-            _t+=1
+        while 1:
+            self.lock.acquire_lock()
 
+            self.artnete_init(Bdmx)
+
+            t = clock.time()
+            self._coarse_loop(Bdmx,t)
+            self._fine_loop(Bdmx,t)
 
             self.lock.release_lock()
 
             for k,artnet in self.artnet.items():
                 artnet.next()
 
-            fps += 1
-            stop_fps = 50
             time.sleep(1/30)
-            if fps >= stop_fps:
-                fps_t = time.time()
-                FPS = round(stop_fps/(fps_t-fps_start),2)
-                print("{:0.0f} core/fps".format(FPS) ) 
-                fps = 0
-                fps_start = time.time()
-
-main = Main()
+            self.calc_fps()
+
+core = Core()
 if __run_main:
-    thread.start_new_thread(main.loop,())
+    thread.start_new_thread(core.loop,())
 
 
 def _init_action(row):#Bdmx,out,DMX):
@@ -1116,6 +1090,30 @@ def _parse_master(x):
     if "SIZE-MASTER" == x["CMD"]:
         size_master.val(x["NR"],x["VALUE"])
 
+
+def _check_vmaster(DMX,attr):
+    if DMX <= 0 and "DIM" == attr:
+        return True
+
+def _get_vmaster(_fix_id,attr):
+    if _fix_id not in V_MASTER:
+        print(" VMASTER init",_fix_id)
+        V_MASTER[_fix_id] = DMXCH()
+        V_MASTER[_fix_id].name = "vmaster_"+str(_fix_id)
+
+    Admx = V_MASTER[_fix_id]
+    return Admx
+
+
+def _get_dmx(DMX,Bdmx):
+    if DMX < len(Bdmx):
+        Admx = Bdmx[DMX-1]
+    else:
+        Admx = DMXCH() #dummy
+        Admx.name = "get-dmx-dummy"
+        print("DMX ADDRESS too BIG",DMX)
+    return Admx
+
 def _parse_cmds(cmds,clock=0):
     out = {}
     for cmd in cmds:
@@ -1128,106 +1126,74 @@ def _parse_cmds(cmds,clock=0):
             raise e
     return out
 
+def _check_cmd(cmd):
+    err=0
+    if not isinstance(cmd,dict):
+        cprint("_check_cmd() ... cmd is not dict !",type(cmd),color="red")
+        err=1
+    if "DMX" not in cmd:
+        cprint("_check_cmd() ... 'DMX' not in x!",color="red")
+        err=1
+    if "VALUE" not in cmd:
+        cprint("_check_cmd() ... 'VALUE' not in x!",color="red")
+        err=1
+    if err:
+        return
+    return True
+
 def _parse_cmd(out,cmd,clock=0):
-    #print("_parse_cmd",out,cmd)
+
+    if not isinstance(out,dict):
+        cprint("_parse_cmd() ... out !",type(out),color="red")
+        return
+
+    if not _check_cmd(cmd):
+        return
+
+    if "CMD" in cmd:
+        _parse_master(x)
+        return 
+
     master_fx = MASTER_FX()
-    Admx = DMXCH() #dummy
-    x=cmd
     c=clock
 
-    _fix_id=0
-    _attr = ""
-    if "CMD" in x:
-        _parse_master(x)
-        return #continue
-    
-    if "DMX" not in x:
-        return #continue
-    DMX = int(x["DMX"])
-
-    if "VALUE" not in x:
-        return #continue
-
-    _val = x["VALUE"]
-    _inc = 0
-    _fix_id = 0
-    _clock = 0
-    exec_id = None
-
-    if "INC" in x:
-        _inc = x["INC"]
-    if "FIX" in x:
-        _fix_id = x["FIX"]
-    if "clock" in x:
-        _clock=x["clock"]
-    if "ATTR" in x:
-        _attr = x["ATTR"]
-
-    if DMX <= 0: # VIRTUAL
+    DMX = cmd.get("DMX",0)
+    DMX = int(DMX)
+
+    exec_id = cmd.get("EXEC",None)
+    _fix_id = cmd.get("FIX",0)
+    _attr   = cmd.get("ATTR","")
+    _clock  = cmd.get("clock",0)
+    _val    = cmd.get("VALUE","")
+    _inc    = cmd.get("INC",0)
+    fx      = cmd.get("FX","")
+    fx2     = cmd.get("FX2",{})
+    ftime   = cmd.get("FADE",0)
+    delay   = cmd.get("DELAY",0)
+
+    #print("cmd",cmd)
+
+    Admx = _get_dmx(DMX,Bdmx)
+
+    if _check_vmaster(DMX,_attr):
+        Admx = _get_vmaster(_fix_id,_attr)
         DMX = "FIX"+str(_fix_id)
-        ok = 0
-        if "ATTR" in x:
-            _attr = x["ATTR"]
-            if "DIM" == x["ATTR"]:
-                if _fix_id not in V_MASTER:
-                    V_MASTER[_fix_id] = DMXCH()
-                #print("_val",_val)
-                #V_MASTER[_fix_id].fade(_val,ftime=0,clock=0,delay=0)
-                #print("  V-MASTER",_fix_id,_val,_inc)
-                ok = 1
-
-        if _fix_id in V_MASTER:
-            Admx = V_MASTER[_fix_id]
-
-        if not ok:
-            return #continue
 
-    else:
-        if DMX < len(Bdmx):
-            Admx = Bdmx[DMX-1]
-        else:
-            print("DMX ADDRESS too BIG",DMX)
-            return #continue 
 
-    
-    if "DMX-FINE" in x and DMX > 0:
-        set_dmx_fine_ch(Admx, x["DMX-FINE"])
-
-    if "EXEC" in x:
-        exec_id = x["EXEC"]
-    if "ATTR" in x:
-        _attr = x["ATTR"]
-    if "FIX" in x:
-        _fix_id = x["FIX"]
-
-
-    fx=""
-    fx2={}
-    ftime=0
-    delay=0
-    if "FX" in x:
-        fx = x["FX"]
-    if "FX2" in x:
-        fx2 = x["FX2"]
-    if "FADE" in x:
-        ftime = x["FADE"]
-    if "DELAY" in x:
-        delay = x["DELAY"]
-
-
-    #print("DO",[exec_id],x)
-    # ids = [401,402,304,103] 
-    # exec-id, exec-fx-id, flush-id, flush-fx-id
+    DMX_FINE = cmd.get("DMX-FINE",-1) 
+    if DMX_FINE > 0:
+        set_dmx_fine_ch(Admx, DMX_FINE)
+
+    ids = Admx.exec_ids()
+
     if _val != "off":
-        if "FLASH" in x:
-            ids = Admx.exec_ids()
+        if "FLASH" in cmd:
             if type(_val) is int:
                 ids[2] = exec_id
             if fx2:
                 ids[3] = exec_id
             #print(" ",[ids, exec_id],"FL")
         else: # GO or ON
-            ids = Admx.exec_ids()
             if type(_val) is int:
                 ids[0] = exec_id
             if fx2:
@@ -1237,8 +1203,7 @@ def _parse_cmd(out,cmd,clock=0):
     if _val == "off":
         # flash bug if lot's of virtual dimmer are  RELEASED-FROM-FLASH ("FLASH off") 
         # the V-MASTER FLASH ist HANGING ... no ENCODER change possible !!! ???
-        if 0: # "FLASH" in x:
-            ids = Admx.exec_ids()
+        if 0: # "FLASH" in cmd:
             stop = 0
             #print(" ",[ids, exec_id])
             if ids[2] != exec_id:
@@ -1257,22 +1222,17 @@ def _parse_cmd(out,cmd,clock=0):
                 return #continue
 
 
-    #aprint("OK")        
-    #ids = Admx.exec_ids()
-    #print("OK ",[ids, exec_id])
-
-    #Bdmx[DMX].exec_id(exec_id)
     out[DMX] = {"flash":{},"fade":{},"fx":{},"flash_fx":{},"fix_id":_fix_id,"attr":_attr,"DMXCH":Admx}
     if _val is not None:
         Xval = {"target":_val,"ftime":ftime, "clock":c,"delay":delay,"DMXCH":Admx}
         mode = "fade"
-        if "FLASH" in x:
+        if "FLASH" in cmd:
             mode = "flash"
         out[DMX][mode]  = Xval
 
 
     # FX PARSE
-    _fx2 = _parse_fx2(x,fx2,clock=c)
+    _fx2 = _parse_fx2(cmd,fx2,clock=c)
     if _fx2:
        _key=_fx2[0] # fx, fx_flash
        Xval=_fx2[1] # dict
@@ -1284,7 +1244,7 @@ def _parse_cmd(out,cmd,clock=0):
         # old fx like sinus:200:12:244 
         ccm = str(DMX+1)+":"+fx
         print("fx",ccm)
-        if "FLASH" in x:
+        if "FLASH" in cmd:
             pass #CB({"cmd":"fxf"+ccm})
         else:
             pass #CB({"cmd":"fx"+ccm})
@@ -1371,7 +1331,7 @@ def JCB(data,sock=None): #json client input
         return
 
     try:
-        main.lock.acquire_lock()
+        core.lock.acquire_lock()
         for _id in out:
             row = out[_id]
             #print(" ",_id,[str(row)])
@@ -1408,7 +1368,7 @@ def JCB(data,sock=None): #json client input
         cprint("Error on line {}".format(sys.exc_info()[-1].tb_lineno),color="red")
         raise e
     finally:
-        main.lock.release_lock()
+        core.lock.release_lock()
 
     #cprint(" ","{:0.04} sec.".format(time.time()-t_start),color="yellow")
     print("attr_count:",attr_count)
@@ -1421,14 +1381,14 @@ def JCB(data,sock=None): #json client input
     print(msg)
     time.sleep(1/60)
             
-def main():
+def jcb_loop():
     s = chat.Server(cb=JCB)
     while 1:
         s.poll()
         time.sleep(0.001)
 
 if __run_main:
-    main()    
+    jcb_loop()