Merge remote-tracking branch 'origin/fakeserver' into fakeserver

This commit is contained in:
Maximilien Rigaut 2021-10-11 21:34:02 +02:00
commit 8d89527458
3 changed files with 6010 additions and 351 deletions

View File

@ -1,6 +1,5 @@
# pythonAnalogWay # pythonAnalogWay
Python binds for analogway controllers Python binds for analogway controllers
* TODO : Verbosity levels
* TODO : Do something with all the value obtained * TODO : Do something with all the value obtained
* TODO : Add a custom .release method to finetune everything * MAYBE: Taka available could be a global variable set to False every change made.

View File

@ -12,7 +12,6 @@ from _thread import start_new_thread
_IPSELF = "192.168.0.140" # Could be usefull for multi IP networks _IPSELF = "192.168.0.140" # Could be usefull for multi IP networks
_HOSTS = [("192.168.0.140",10500)] _HOSTS = [("192.168.0.140",10500)]
_VERBOSE=True
_MSGSIZE=4096 _MSGSIZE=4096
_TIMEOUT=4 _TIMEOUT=4
@ -28,22 +27,28 @@ def _SYS_EXIT(system,*args):
system.fatal=True system.fatal=True
sys.exit() sys.exit()
if _VERBOSE:
def dprint(*args): _VERBOSE=4
print(*args)
def spec_print(spec,*args): nopeF=lambda *x:None
dprint("[pAW:{}]".format(spec),*args) #(line@{}) ,sys._getframe().f_lineno def printl(label=""):
def iprint(*args): def _pl(*args):
spec_print("INFO",*args) print(label,*args)
def wprint(*args): return _pl
spec_print("WARNING",*args)
def eprint(*args): eprint=printl("[pAW:ERROR]")
spec_print("ERROR",*args) dprint=nopeF
else: ddprint=nopeF
dprint=_NO_FUNCT iprint=nopeF
wprint=_NO_FUNCT wprint=nopeF
eprint=_NO_FUNCT if _VERBOSE>=1:
iprint=_NO_FUNCT wprint=printl("[pAW:WARNING]")
if _VERBOSE>=2:
iprint=printl("[pAW:INFO]")
if _VERBOSE>=3:
dprint=printl("[pAW:DEBUG]")
if _VERBOSE>=4:
ddprint=printl("[pAW:DDEBUG]")
class pyNope(object): class pyNope(object):
@ -141,7 +146,7 @@ _FILTER={
# PROGRESS "PSprg99" # PROGRESS "PSprg99"
# GCfrl ? # GCfrl ?
# GCply # 0,0GCtio ?
_MESSAGE_REGEX=re.compile("(?P<preargs>(\d)*(,\d)*)(?P<msg>\D*)(?P<postargs>(\d)*(,\d)*)") _MESSAGE_REGEX=re.compile("(?P<preargs>(\d)*(,\d)*)(?P<msg>\D*)(?P<postargs>(\d)*(,\d)*)")
_MATCHS={ _MATCHS={
@ -152,20 +157,32 @@ _MATCHS={
"SYpig":"KPALIVE", "SYpig":"KPALIVE",
"PRinp":"LAYERINP", #? "PRinp":"LAYERINP", #?
"GCtak":"TAKE", #GCtak<scrn>,0 "GCtak":"TAKE", #GCtak<scrn>,0
"GCtav":"TAKEAVL",
"GCtal":"TAKEALL", #GCtal0 "GCtal":"TAKEALL", #GCtal0
"GClrq":"LOADMM", #GClrq ? "GClrq":"LOADMM", #GClrq ?
"CTqfl":"QUICKFA", #X,1CTqfl "CTqfl":"QUICKFA", #X,1CTqfl
"CTqfa":"QUICKF", #1CTqfa "CTqfa":"QUICKF", #1CTqfa
"PUscu":"SCRNUPD", #1PUscu
"GCfsc":"FREEZE",
"GCfra":"FREEZEALL",
"GCfrl":"FREEZELAYER",
"GCply":"DISPLAYLAYER",
"E":"ERROR"
} }
_ALL_MESSAGE_TYPES=[ _ALL_MESSAGE_TYPES=[
"CONNECT","DEVICE","VERSION","STATUS","KPALIVE","LAYERINP", "CONNECT","DEVICE","VERSION","STATUS","KPALIVE","LAYERINP",
"TAKEAVL","TAKE","TAKEALL","LOADMM","QUICKFA","QUICKF" "TAKEAVL","TAKE","TAKEALL","LOADMM","QUICKFA","QUICKF",
"SCRNUPD","FREEZE","FREEZEALL","FREEZELAYER","DISPLAYLAYER",
"ERROR"
] ]
_UPDATE_MSG=[ _UPDATE_MSG=[
"LAYERINP","QUICKFA","QUICKF", "LAYERINP","QUICKFA","QUICKF","TAKE","QUICKFA","QUICKF","FREEZE","FREEZEALL","DISPLAYLAYER",
] ]
# RELOAD_PROGRAM
# FREEZE_SCREEN
# FREEZE_ALL
################################ ################################
# CLASS DEFINITIONS # CLASS DEFINITIONS
@ -182,9 +199,13 @@ class analogController(object):
self.fatal=False self.fatal=False
self.lastping=0 self.lastping=0
self.st_quickframe=[False,False] self.st_quickframe=[False,False]
self.st_takeavailable=[False,False]
self.st_quickframeall=False self.st_quickframeall=False
self._connectedLock=threading.Lock() self._connectedLock=threading.Lock()
self._connectedLock.acquire() # Waiting for connection self._connectedLock.acquire() # Waiting for connection
self.st_freeze=[False,False]
self.st_freeze_all=False
self.st_freeze_layer=[False,False]
self.feedback=feedbackInterface # Feedback interface gui or midiRebind self.feedback=feedbackInterface # Feedback interface gui or midiRebind
self._LOCKS={i:threading.Lock() for i in _ALL_MESSAGE_TYPES} #LAYERINP could actually be a huge clusterlock, not for now tho self._LOCKS={i:threading.Lock() for i in _ALL_MESSAGE_TYPES} #LAYERINP could actually be a huge clusterlock, not for now tho
# for i in range(2): # for i in range(2):
@ -194,16 +215,16 @@ class analogController(object):
self.POSTMATCHACTIONS={i:self.getAttr("POSTMATCH_{}".format(i),self.POSTMATCH_GENERIC) for i in _ALL_MESSAGE_TYPES} self.POSTMATCHACTIONS={i:self.getAttr("POSTMATCH_{}".format(i),self.POSTMATCH_GENERIC) for i in _ALL_MESSAGE_TYPES}
try: try:
iprint('Creating socket') dprint('Creating socket')
self.sck = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.sck = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# iprint('Getting remote IP address') # iprint('Getting remote IP address')
# remote_ip = socket.gethostbyname(_IPSELF) # remote_ip = socket.gethostbyname(_IPSELF)
# iprint(remote_ip) # iprint(remote_ip)
except socket.error: except socket.error:
print('[pAW:ERROR] Failed to create socket') eprint('Failed to create socket')
sys.exit() sys.exit()
except socket.gaierror: except socket.gaierror:
print('[pAW:ERROR] Hostname could not be resolved. Exiting') eprint('Hostname could not be resolved. Exiting')
sys.exit() sys.exit()
def getAttr(self,attribute,default): def getAttr(self,attribute,default):
@ -217,6 +238,7 @@ class analogController(object):
# RECEIVE ANALISIS # RECEIVE ANALISIS
def POSTMATCH_GENERIC(self,match): def POSTMATCH_GENERIC(self,match):
"Expects a 0 as last argument to proceed" "Expects a 0 as last argument to proceed"
self.st_takeavailable=[False,False]
if match.group("postargs").split(",")[-1]!="0": if match.group("postargs").split(",")[-1]!="0":
return False return False
return True return True
@ -233,14 +255,32 @@ class analogController(object):
"Accepts any version" "Accepts any version"
return True return True
def POSTMATCH_LAYERINP(self,match):
"Accepts any layer configuration"
self.st_takeavailable=[False,False]
return True
def POSTMATCH_KPALIVE(self,match): def POSTMATCH_KPALIVE(self,match):
"Accepts only the invert of last ping" "Accepts only the invert of last ping"
if match.group("postargs")!=str(0xFFFFFFFF^self.lastping): if match.group("postargs")!=str(0xFFFFFFFF^self.lastping):
return False wprint("Sent {:b} | Expected {:b} and got {:b}".format(self.lastping,0xFFFFFFFF^self.lastping,int(match.group("postargs"))))
return True
return True return True
def POSTMATCH_ERROR(self,match):
"Error message"
self.st_takeavailable=[False,False]
eprint("An error has occured on the machine side:")
if match.group("postargs")=="10":
eprint("Command name error. It is usually due to a command field (i.e. five letters) that does not match any legal command string")
elif match.group("postargs")=="11":
eprint("Index value out of range. It is usually due to a wrong index value.")
elif match.group("postargs")=="12":
eprint("Index number error. It is usually due to an incorrect number of indexes, too much or not enough.")
def POSTMATCH_QUICKF(self,match): def POSTMATCH_QUICKF(self,match):
"Update quickframe status" "Update quickframe status"
self.st_takeavailable=[False,False]
screen,status=match.group("postargs").split(",") screen,status=match.group("postargs").split(",")
screen,status=int(screen),int(status) screen,status=int(screen),int(status)
self.st_quickframe[screen]=status self.st_quickframe[screen]=status
@ -248,11 +288,55 @@ class analogController(object):
def POSTMATCH_QUICKFA(self,match): def POSTMATCH_QUICKFA(self,match):
"Update quickFrameAll status" "Update quickFrameAll status"
self.st_takeavailable=[False,False]
status=int(match.group("postargs")) status=int(match.group("postargs"))
for i in range(len(self.st_quickframe)): for i in range(len(self.st_quickframe)):
self.st_quickframe[i]=status self.st_quickframe[i]=status
self.st_quickframeall=status self.st_quickframeall=status
return True return True
def POSTMATCH_TAKEAVL(self,match):
"Take available answer 1"
# Write take availability
scr,avail=match.group("postargs").split(",")
if avail=="1":
self.st_takeavailable[int(scr)]=True
return True
self.st_takeavailable[int(scr)]=False
return False
def POSTMATCH_TAKE(self,match):
"Take answer 1"
self.st_takeavailable=[False,False]
if match.group("postargs")[-1]=="0":
return True
return False
def POSTMATCH_SCRNUPD(self,match):
"Take answer 1"
if match.group("postargs")[-1]=="1":
return True
return False
def POSTMATCH_FREEZEALL(self,match):
"Take answer 1"
if match.group("postargs")[-1]=="1":
return True
return False
def POSTMATCH_DISPLAYLAYER(self,match):
"Returns the displayed layer"
return True
def POSTMATCH_FREEZELAYER(self,match):
"Returns the layer,screen and status of the freeze"
return True
# def POSTMATCH_TAKEAVL(self,match):
# "Take available answer 1"
# if match.group("postargs")[-1]=="1":
# return True
# return False
################################ ################################
# MESSAGE RECEIVE # MESSAGE RECEIVE
def genericRECEIVE(self,match): def genericRECEIVE(self,match):
@ -268,16 +352,17 @@ class analogController(object):
if typ in _UPDATE_MSG: if typ in _UPDATE_MSG:
return self.feedback.messageReceived(typ,match) return self.feedback.messageReceived(typ,match)
else: else:
wprint("Ignoring message",match) dprint("Ignoring message",match)
return status return status
except RuntimeError as e: except RuntimeError as e:
iprint("Lock [{}] is already released (async terminated earlier)".format(typ)) dprint("Lock [{}] is already released (async terminated earlier)".format(typ))
iprint("This message is either comming from the device or garbage data") dprint("This message is either comming from the device or garbage data")
iprint(e) dprint(e)
except KeyError as e: except KeyError as e:
eprint("There is no lock associated with {}".format(typ)) eprint("There is no lock associated with {}".format(typ))
print(e) print(e)
return False return False
############################################## ##############################################
# LOCKS # LOCKS
def waitLock(self,lockname,function_success=_NO_FUNCT,args_success=(),function_error=_NO_FUNCT,args_error=(),timeout=_TIMEOUT): def waitLock(self,lockname,function_success=_NO_FUNCT,args_success=(),function_error=_NO_FUNCT,args_error=(),timeout=_TIMEOUT):
@ -288,17 +373,17 @@ class analogController(object):
def _initLockWait(self,lockname,function_success=_NO_FUNCT,args_success=(),function_error=_NO_FUNCT,args_error=(),timeout=_TIMEOUT): def _initLockWait(self,lockname,function_success=_NO_FUNCT,args_success=(),function_error=_NO_FUNCT,args_error=(),timeout=_TIMEOUT):
"""Thread waiting for a lock""" """Thread waiting for a lock"""
iprint("Checking for [{}] lock avaivability".format(lockname)) dprint("Checking for [{}] lock avaivability".format(lockname))
if not self._LOCKS[lockname].locked(): #The state it's supposed to be in, but let's not be too sure if not self._LOCKS[lockname].locked(): #The state it's supposed to be in, but let's not be too sure
self._LOCKS[lockname].acquire(timeout=0.01) self._LOCKS[lockname].acquire(timeout=0.01)
# Now wait for the lock to be released # Now wait for the lock to be released
iprint("Acquired [{}] : Locking".format(lockname)) dprint("Acquired [{}] : Locking".format(lockname))
status=self._LOCKS[lockname].acquire(timeout=timeout) status=self._LOCKS[lockname].acquire(timeout=timeout)
if status: if status:
iprint("Lock [{}] passed succesfully".format(lockname)) dprint("Lock [{}] passed succesfully".format(lockname))
function_success(args_success) function_success(args_success)
else: else:
iprint("Failed to aquire [{}]".format(lockname)) eprint("Failed to aquire [{}]".format(lockname))
function_error(args_error) function_error(args_error)
return status return status
@ -307,7 +392,8 @@ class analogController(object):
def genericSEND(self,lock,send,fatal=True,*args,**kwargs): def genericSEND(self,lock,send,fatal=True,*args,**kwargs):
"Generic send and join method, with all the logic on the controler side" "Generic send and join method, with all the logic on the controler side"
iprint("Acquiring {}".format(lock.lower())) dprint("Acquiring {}".format(lock.lower()))
# self.st_takeavailable=[False,False] # ?
wait=self.waitLock(lock,function_error=_SYS_EXIT,args_error=(self),*args,**kwargs) wait=self.waitLock(lock,function_error=_SYS_EXIT,args_error=(self),*args,**kwargs)
self.sendData(send) self.sendData(send)
wait.join() wait.join()
@ -323,28 +409,29 @@ class analogController(object):
self.sck.connect((self.ip,self.port)) self.sck.connect((self.ip,self.port))
self._connectedLock.release() self._connectedLock.release()
self.genericSEND("CONNECT","*") self.genericSEND("CONNECT","*")
self.genericSEND("CONNECT","*\r\n")
def getDevice(self): def getDevice(self):
"""This read only command gives the device type """This read only command gives the device type
[?] (DEV <value>) <values>:_DEVICES_VALUES [?] (DEV <value>) <values>:_DEVICES_VALUES
""" """
self.genericSEND("DEVICE","?") self.genericSEND("DEVICE","?\r\n")
def getVersion(self): def getVersion(self):
"""his read only command gives the version number of the command set. """his read only command gives the version number of the command set.
It is recommended to check that this value matches the one expected by the controller. It is recommended to check that this value matches the one expected by the controller.
[VEvar] (VEvar<version>) [VEvar] (VEvar<version>)
""" """
self.genericSEND("VERSION","VEvar") self.genericSEND("VERSION","VEvar\r\n")
def getStatus(self,value=3): def getStatus(self,value=1,timeout=_TIMEOUT_HUGE):
"""Reading a change of values """Reading a change of values
[<value>#] (# <rvalue>) The controller must wait for <rvalue> to equals 0 for the end of enumeration [<value>#] (# <rvalue>) The controller must wait for <rvalue> to equals 0 for the end of enumeration
<value>:1 All register values 3: Only non default values <value>:1 All register values 3: Only non default values
""" """
self.genericSEND("STATUS",'#{}'.format(value),timeout=_TIMEOUT_BIG) self.genericSEND("STATUS",'{}#'.format(value),timeout=timeout)
def _keepAlive(self,val=1): def _keepAlive(self,val=0x0000):
"""Send a keepalive to check (and ensure) the connection is still up """Send a keepalive to check (and ensure) the connection is still up
[<val1>SYpig] Will return the invert of the value sent: 0x0000 0000 will return 0xFFFF FFFF [<val1>SYpig] Will return the invert of the value sent: 0x0000 0000 will return 0xFFFF FFFF
""" """
@ -366,8 +453,13 @@ class analogController(object):
[<scrn>,GCtav] Test take availability on screen <scrn> [<scrn>,GCtav] Test take availability on screen <scrn>
(GCtav<scrn>,0) : Take is unavailable (GCtav<scrn>,0) : Take is unavailable
(GCtav<scrn>,1) : Take is available""" (GCtav<scrn>,1) : Take is available"""
self.st_takeavailable=[False,False]
for screen in screens: for screen in screens:
self.genericSEND("TAKEAVL","{screen},GCtav".format(screen=screen),timeout=_TIMEOUT_BIG) # print(screen)
self.genericSEND("TAKEAVL","{screen},GCtav".format(screen=screen),timeout=_TIMEOUT_HUGE)
# self.genericSEND("TAKEAVL","{screen},GCtav".format(screen=screen),timeout=_TIMEOUT_HUGE)
def takeAvailableAll(self):
self.takeAvailable(*range(self.screens))
def take(self,screen): def take(self,screen):
""" Take a specific screen """ Take a specific screen
@ -379,7 +471,9 @@ class analogController(object):
(GCtav<scrn>,1) : Take is available (GCtav<scrn>,1) : Take is available
""" """
# Check if take available on all screens # Check if take available on all screens
self.genericSEND("TAKE","{screen},1GCtak".format(screen=screen),timeout=_TIMEOUT_BIG) self.updateFinished(screen)
if self.st_takeavailable[screen]:
self.genericSEND("TAKE","{screen},1GCtak".format(screen=screen),timeout=_TIMEOUT_HUGE)
def takeAll(self): def takeAll(self):
"""Take all screens """Take all screens
@ -395,9 +489,13 @@ class analogController(object):
(GCtak<scrn>,1) : Take is available (GCtak<scrn>,1) : Take is available
""" """
# Wait for all screens to be available # Wait for all screens to be available
self.takeAvailable(range(self.screens)) # self.takeAvailable(0)#*range(self.screens))
self.genericSEND("TAKEALL","1,GCtal",timeout=_TIMEOUT_BIG) self.updateFinishedAll()
if self.st_takeavailable[0]&self.st_takeavailable[1]:
self.genericSEND("TAKEALL","1GCtal",timeout=_TIMEOUT_BIG)
else:
self.takeAvailableAll(screen)
self.takeAll()
def loadMM(screenF,memory,screenT,ProgPrev,filter): def loadMM(screenF,memory,screenT,ProgPrev,filter):
"""Load a master memory to a screen """Load a master memory to a screen
@ -420,7 +518,8 @@ class analogController(object):
""" """
if action == None: if action == None:
action=not self.st_quickframe[screen] action=not self.st_quickframe[screen]
self.genericSEND("QUICKF","{screen},{action}CTqfa".format(screen=screen,action=action)) self.genericSEND("QUICKF","{screen},{action:b}CTqfa".format(screen=screen,action=action))
# self.sendDirect("{screen},{action}CTqfa".format(screen=screen,action=action).encode())
self.st_quickframe[screen]=action self.st_quickframe[screen]=action
def quickFrameAll(self,action=None): def quickFrameAll(self,action=None):
@ -430,16 +529,61 @@ class analogController(object):
""" """
if action == None: if action == None:
action=not self.st_quickframeall action=not self.st_quickframeall
self.genericSEND("QUICKFA","{action}CTqfl".format(action=action)) self.genericSEND("QUICKFA","{action:b}CTqfl".format(action=action))
self.st_quickframeall=action self.st_quickframeall=action
def freezeScreen(self,screen,action=False):
"""Freeze screen <screen>
<screen>,1GCfsc: Freeze screen
<screen>,0GCfsc: Un Freeze screen ?
"""
if action==None:
action=not self.st_freeze[screen]
self.genericSEND("FREEZE","{screen},{action:b}GCfsc".format(screen=screen,action=action))
self.st_freeze[screen]=not action
def freezeScreenAll(self,action=None):
"""Freeze all screens
1GCfra: Freeze screen
"""
if action==None:
action=self.st_freeze_all
self.genericSEND("FREEZEALL","{action:b}GCfra".format(action=action))
self.st_freeze_all=not self.st_freeze_all
def freezeLayer(self,layer,screen,action=None):
"""Freeze layer <layer> on <screen>
<layer>,<screen>,<action>GCfrl: Freeze screen
"""
if action==None:
action=self.st_freeze_layer[layer]
self.genericSEND("FREEZELAYER","{layer},{screen},{action:b}GCfrl".format(layer=layer,screen=screen,action=action))
self.st_freeze_layer[layer]=not self.st_freeze_layer[layer]
def displayed(self,layer):
"""Change the previewed layer
<layer>GCply
"""
self.genericSEND("DISPLAYLAYER","{layer}GCply".format(layer=layer))
def updateFinished(self,screen):
"""Updates are finished being sent
<screen>,1PUscu : Updates on screen <screen> are done
"""
self.genericSEND("SCRNUPD","{screen},1PUscu".format(screen=screen))
def updateFinishedAll(self):
for screen in range(self.screens):
self.updateFinished(screen)
def connectionSequence(self): def connectionSequence(self):
"Execute the full connection sequence" "Execute the full connection sequence"
self.start_listening() self.start_listening()
self.connect() self.connect()
self.getDevice() self.getDevice()
self.getVersion() self.getVersion()
self.getStatus() # self.getStatus(3)
######################################### #########################################
# SOCKET METHODS # SOCKET METHODS
@ -471,8 +615,9 @@ class analogController(object):
except AttributeError as e: except AttributeError as e:
dprint(e) dprint(e)
except OSError as e: except OSError as e:
dprint(e) eprint(e)
dprint('The socket connection is experiencing issues') eprint('The socket connection is experiencing issues')
def socketLoop(self): def socketLoop(self):
"""Loop on the socket and create an event for every message received""" """Loop on the socket and create an event for every message received"""
@ -480,13 +625,13 @@ class analogController(object):
self._connectedLock.acquire(_TIMEOUT_BIG) # Wait for connection self._connectedLock.acquire(_TIMEOUT_BIG) # Wait for connection
for message in self.cleanReceive(): for message in self.cleanReceive():
try: try:
iprint ("Received:",message) iprint ("<<< Received:",message)
RX_MTCH=_MESSAGE_REGEX.match(message) RX_MTCH=_MESSAGE_REGEX.match(message)
iprint("preargs:{} - msg:{} - postargs:{}".format(RX_MTCH.group("preargs"),RX_MTCH.group("msg"),RX_MTCH.group("postargs"))) dprint("preargs:{} - msg:{} - postargs:{}".format(RX_MTCH.group("preargs"),RX_MTCH.group("msg"),RX_MTCH.group("postargs")))
start_new_thread(self.processMatch,(RX_MTCH,)) # Here lies the problem, damned if I do, damned if I don't start_new_thread(self.processMatch,(RX_MTCH,)) # Here lies the problem, damned if I do, damned if I don't
except AttributeError as e: except AttributeError as e:
dprint("[pAW:ERROR] Regex couldn't find a match") eprint("Regex couldn't find a match")
dprint(e) eprint(e)
def processMatch(self,match): def processMatch(self,match):
"""Process a match with a message, should only be called by the socketLoop funciton""" """Process a match with a message, should only be called by the socketLoop funciton"""
@ -495,13 +640,23 @@ class analogController(object):
# self.__getattribute__("receive_{}".format(name),default="GENERIC")(match) # self.__getattribute__("receive_{}".format(name),default="GENERIC")(match)
return self.genericRECEIVE(match) return self.genericRECEIVE(match)
except KeyError as e: except KeyError as e:
dprint("[pAW:ERROR] Can't find matched key:",match) # dprint("[pAW:ERROR] Can't find matched key:",match)
print(e) # print(e)
pass
def sendDirect(self,direct):
"Directly sent to the socket"
try:
iprint(">>> Sending direct: {}".format(direct))
self.sck.sendall(direct)
except:
eprint("Error sending data: ",direct)
def sendData(self,data): def sendData(self,data):
"Send data through the socket" "Send data through the socket"
try: try:
self.sck.sendall((data+'\r\n').encode()) iprint(">>> Sending data: {}".format(data.replace("\n","")))
self.sck.sendall((data).encode())
except socket.error: except socket.error:
print ('[pAW:ERROR] Send failed of data :',data) print ('[pAW:ERROR] Send failed of data :',data)
sys.exit() sys.exit()
@ -514,7 +669,7 @@ class analogController(object):
def pingLoop(self): def pingLoop(self):
"Another limbo wait, this time with pings" "Another limbo wait, this time with pings"
while not self.fatal: while not self.fatal:
self._keepAlive() self._keepAlive(val=0b1000)
time.sleep(_TIMEOUT_HUGE) time.sleep(_TIMEOUT_HUGE)
def keepPinging(self,timer=_TIMEOUT_HUGE): def keepPinging(self,timer=_TIMEOUT_HUGE):
@ -524,12 +679,68 @@ class analogController(object):
threading.Timer(timer,self.keepPinging,(timer,)).start() threading.Timer(timer,self.keepPinging,(timer,)).start()
self._keepAlive() self._keepAlive()
def __del__(self):
self.sck.close()
def close(self):
self.__del__()
# threading.Timer(self._keepPinging(timer),timer) # threading.Timer(self._keepPinging(timer),timer)
##################### #####################
# TESTING # TESTING
if __name__ == '__main__': if __name__ == '__main__':
_HOSTS=[["127.0.0.1",3000]] # Test server _HOSTS=[["127.0.0.1",3000]] # Test server
_TIMEOUT_HUGE=1 _TIMEOUT_HUGE=5
ctrl1=analogController(*_HOSTS[0]) ctrl1=analogController(*_HOSTS[0])
ctrl1.connectionSequence() ctrl1.connectionSequence()
ctrl1.keepPinging() # while True:
# for i in range(8):
# ctrl1.changeLayer(0,1,1,i+1)
# time.sleep(0.5)
# ctrl1.changeLayer(0,1,2,i+1)
# time.sleep(1)
# try:
# while True:
# txt=input("> ")
# ctrl1.sendDirect(txt.encode())
# except KeyboardInterrupt:
# ctrl1.close()
ctrl1.changeLayer(0,0,1,1)
# time.sleep(1)
# # ctrl1.freezeScreenAll(1)
# ctrl1.freezeLayer(0,0,1)
# ctrl1.freezeLayer(1,0,1)
# time.sleep(1)
ctrl1.displayed(0)
# ctrl1.freezeScreenAll(1)
# import random
# while True:
# # ctrl1.changeLayer(0,1,1,random.randint(0,7))
# # ctrl1.updateFinishedAll()
# # ctrl1.takeAvailableAll()
# # ctrl1.takeAll()
# input(">>>")
# ctrl1.displayed(1)
# ctrl1.updateFinishedAll()
# ctrl1.freezeLayer(0,1)
# time.sleep(1)
# # ctrl1.takeAvailable((1,))
# # take(self,screen)
# # takeAll(self)
# # loadMM(screenF,memory,screenT,ProgPrev,filter)
# # ctrl1.quickFrame(0)
# # time.sleep(1)
# # ctrl1.quickFrame(0)
# # time.sleep(1)
# # ctrl1.quickFrame(0)
# #
# # ctrl1.quickFrameAll(action=1)
# # time.sleep(1)
# # ctrl1.quickFrameAll()
# ctrl1.takeAvailable(1)
# ctrl1.keepPinging()

File diff suppressed because it is too large Load Diff