Added a solid base for the server

Must now work on some return analysis to get useful data
This commit is contained in:
Maximilien Rigaut 2021-09-30 22:28:17 +02:00
parent f88335fc7b
commit 193e790a51
3 changed files with 110 additions and 65 deletions

View File

@ -2,7 +2,7 @@
Python binds for analogway controllers Python binds for analogway controllers
* TODO : If connect returns 0 wait another connect * TODO : Do a prefilter on the messages in order not to saturate the gui/rebind with calls for things that are not actually done
* TODO : Verbosity levels * TODO : Verbosity levels
* TODO : Do something with all the value obtained * TODO : Do something with all the value obtained
* TODO : Do a fakeserver * TODO : Add a custom .release method to finetune everything

View File

@ -16,6 +16,8 @@ _VERBOSE=True
_MSGSIZE=4096 _MSGSIZE=4096
_TIMEOUT=0.5 _TIMEOUT=0.5
_TIMEOUT_BIG=5
_TIMEOUT_HUGE=20
_MSG_ENDING=b"\r\n" _MSG_ENDING=b"\r\n"
################################ ################################
@ -48,6 +50,9 @@ class pyNope(object):
def __init__(self): def __init__(self):
pass pass
def messageReceived(self,*args):
iprint("An order has been received :",args)
def __call__(self,*args,**kwargs): def __call__(self,*args,**kwargs):
return self return self
@ -117,11 +122,11 @@ _FILTER={
################################ ################################
# Regex for messages # Regex for messages
_WAIT_CONNECT=re.compile('\*1') # _WAIT_CONNECT=re.compile('\*1')
_WAIT_DEVICE =re.compile('DEV(?P<device>\d*)') # _WAIT_DEVICE =re.compile('DEV(?P<device>\d*)')
_WAIT_VERSION=re.compile('VEvar(?P<version>\d*)') # _WAIT_VERSION=re.compile('VEvar(?P<version>\d*)')
_WAIT_STATUS=re.compile('#(?P<status>\d*)') # _WAIT_STATUS=re.compile('#(?P<status>\d*)')
_WAIT_KPALIVE=re.compile('SYpig(?P<ping>\d*)') # _WAIT_KPALIVE=re.compile('SYpig(?P<ping>\d*)')
# PROGRESS "PSprg99" # PROGRESS "PSprg99"
# GCfrl ? # GCfrl ?
# GCply # GCply
@ -133,7 +138,7 @@ _MATCHS={
"VEvar":"VERSION", "VEvar":"VERSION",
"#":"STATUS", "#":"STATUS",
"SYpig":"KPALIVE", "SYpig":"KPALIVE",
"n":"" "PRinp":"LAYERINP",
} }
@ -150,16 +155,21 @@ class analogController(object):
self.running=True self.running=True
self.listening=False self.listening=False
self.fatal=False self.fatal=False
# Last received match messages # Last received match messages, avoid until forced to
self.messages={i:None for i in ["CONNECT","DEVICE","VERSION","STATUS","KPALIVE","REGEX"]} # self.messages={i:None for i in ["CONNECT","DEVICE","VERSION","STATUS","KPALIVE","REGEX"]}
# #
self.feedback=feedbackInterface # Feedback interface gui or midiRebind self.feedback=feedbackInterface # Feedback interface gui or midiRebind
self._LOCKS={i:threading.Lock() for i in [ self._LOCKS={i:threading.Lock() for i in [
"CONNECT","DEVICE","VERSION","STATUS","KPALIVE","changeLayer", "CONNECT","DEVICE","VERSION","STATUS","KPALIVE","LAYERINP",
"takeAvailable","take","takeAll","loadMM","quickFrame","quickFrameAll" "takeAvailable","take","takeAll","loadMM","quickFrame","quickFrameAll"
]} ]} #LAYERINP could actually be a huge clusterlock, not for now tho
for i in range(2):
for j in range(2):
for k in range(8):
self._LOCKS["LAYERINP{}_{}_{}".format(i,j,k)]=threading.Lock()
self._LOCKS{}
try: try:
iprint('Creating socket') iprint('Creating socket')
self.sck = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.sck = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
@ -181,34 +191,35 @@ class analogController(object):
# self.messages["CONNECT"]=match # self.messages["CONNECT"]=match
# self._LOCKS["connect"].release() # self._LOCKS["connect"].release()
# self.feedback.messageReceived("CONNECT",match) # self.feedback.messageReceived("CONNECT",match)
def receive_GENERIC(self,match): def genericRECEIVE(self,match):
"We received a connect message, all the logic will be on the feedback side" "We received a connect message, all the logic will be on the feedback side"
try: try:
typ=_MATCHS[match.group("msg")] typ=_MATCHS[match.group("msg")]
self.messages[typ]=match #why not, not very clever tho # self.messages[typ]=match # Not very clever tho
self._LOCKS[typ].release() self._LOCKS[typ].release() #TODO : Add a custom .release method to finetune everything
self.feedback.messageReceived("typ",match) self.feedback.messageReceived(typ,match) #Do an actual action
except RuntimeError as e: except RuntimeError as e:
iprint("Lock [{}] is already released (async terminated earlier)".format(typ)) iprint("Lock [{}] is already released (async terminated earlier)".format(typ))
iprint(e) iprint(e)
except KeyError as e:
eprint("There is no lock associated with {}".format(typ))
############################################## ##############################################
# LOCKS # LOCKS
def waitLock(self,lockname,function_success=_NO_FUNCT,args_success=(),function_error=_NO_FUNCT,args_error=()): def waitLock(self,lockname,function_success=_NO_FUNCT,args_success=(),function_error=_NO_FUNCT,args_error=(),timeout=_TIMEOUT):
"""Wait for the lock <lockname> to be released, non blocking""" """Wait for the lock <lockname> to be released, non blocking"""
thd=threading.Thread(target=self._initLockWait,args=(lockname,function_success,args_success,function_error,args_error)) thd=threading.Thread(target=self._initLockWait,args=(lockname,function_success,args_success,function_error,args_error,timeout))
thd.start() thd.start()
return thd return thd
def _initLockWait(self,lockname,function_success=_NO_FUNCT,args_success=(),function_error=_NO_FUNCT,args_error=()): 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)) iprint("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)) iprint("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)) iprint("Lock [{}] passed succesfully".format(lockname))
function_success(args_success) function_success(args_success)
@ -229,59 +240,57 @@ class analogController(object):
self.sck.connect((self.ip,self.port)) self.sck.connect((self.ip,self.port))
wait=self.waitLock("CONNECT",function_error=_SYS_EXIT,args_error=(self)) wait=self.waitLock("CONNECT",function_error=_SYS_EXIT,args_error=(self))
self.sendData("*\r\n") self.sendData("*")
# iprint("Waiting for",wait) # iprint("Waiting for",wait)
wait.join() wait.join()
if self.fatal: if self.fatal:
_SYS_EXIT(self) _SYS_EXIT(self)
# iprint("Finished wait for",wait) # iprint("Finished wait for",wait)
def genericSEND(self,lock,send,fatal=True,*args,**kwargs):
"Generic send and join method, with all the logic on the controler side"
iprint("Acquiring {}".format(lock.lower()))
wait=self.waitLock(lock,function_error=_SYS_EXIT,args_error=(self),*args,**kwargs)
self.sendData(send)
wait.join()
if fatal and self.fatal:
_SYS_EXIT(self)
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
""" """
iprint("Acquiring device type") self.genericSEND("DEVICE","?")
wait=self.waitLock("DEVICE",function_error=_SYS_EXIT,args_error=(self))
self.sendData("?")
wait.join()
if self.fatal:
_SYS_EXIT(self)
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>)
""" """
iprint("Acquiring version") self.genericSEND("VERSION","VEvar")
wait=self.waitLock("VERSION",function_error=_SYS_EXIT,args_error=(self))
self.sendData("VEvar")
wait.join()
if self.fatal:
_SYS_EXIT(self)
def getStatus(self,value=3): def getStatus(self,value=3):
"""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.sendData('#{}'.format(value)) self.genericSEND("STATUS",'#{}'.format(value),timeout=_TIMEOUT_BIG)
def _keepAlive(self,val=1): def _keepAlive(self,val=1):
"""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
""" """
self.sendData("{}SYpig".format(val)) self.genericSEND("KPALIVE","{}SYpig".format(val),timeout=_TIMEOUT_BIG)
def changeLayer(self,screen,ProgPrev,layer,src): def changeLayer(self,screen,ProgPrev,layer,src):
"""Change the layer of selected """Change the layer of selected
[<scrn>,<ProgPrev>,<layer>,<src>PRinp] Change the input on a selected layer [<screen>,<ProgPrev>,<layer>,<src>PRinp] Change the input on a selected layer
<scrn> is the RCS² screen number minus 1. <screen> is the RCS² screen number minus 1. (2)
<ProgPrev> is 0 for Program, 1 for Preview. <ProgPrev> is 0 for Program, 1 for Preview. (2) # Not gonna livechange, so it's ignored
<layer> is a value representing the destination Layer. <layer> is a value representing the destination Layer. (7)
<src> is a value representing the input source. <src> is a value representing the input source. (10)
""" #Rinp0,1,7,5\r\nPRinp0,1,1 """ #Rinp0,1,7,5\r\nPRinp0,1,1
pass self.genericSEND("LAYERINP","{screen},{ProgPrev},{layer},{src}PRinp".format(screen=screen,ProgPrev=ProgPrev,layer=layer,src=src),timeout=_TIMEOUT)
def takeAvailable(self,*screens): def takeAvailable(self,*screens):
"""Test for take availability """Test for take availability
@ -300,6 +309,7 @@ class analogController(object):
(GCtak<scrn>,0) : Take finished <--- Waiting for (GCtak<scrn>,0) : Take finished <--- Waiting for
(GCtav<scrn>,1) : Take is available (GCtav<scrn>,1) : Take is available
""" """
self.genericSEND("TAKE","{screen},1PRinp".format(screen=screen),timeout=_TIMEOUT_BIG)
def takeAll(self): def takeAll(self):
"""Take all screens """Take all screens
@ -348,11 +358,8 @@ class analogController(object):
self.start_listening() self.start_listening()
self.connect() self.connect()
self.getDevice() self.getDevice()
# self.getVersion() self.getVersion()
# self.getStatus() self.getStatus()
######################################### #########################################
# SOCKET METHODS # SOCKET METHODS
@ -402,8 +409,7 @@ class analogController(object):
try: try:
name=_MATCHS[match.group("msg")] name=_MATCHS[match.group("msg")]
# self.__getattribute__("receive_{}".format(name),default="GENERIC")(match) # self.__getattribute__("receive_{}".format(name),default="GENERIC")(match)
self.receive_GENERIC(match) 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)
@ -411,20 +417,35 @@ class analogController(object):
def sendData(self,data): def sendData(self,data):
"Send data through the socket" "Send data through the socket"
try: try:
self.sck.sendall(data.encode()) self.sck.sendall((data+'\r\n').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()
def limbowait(self): def limbowait(self):
"Testing state, only usefull when not on a remote gui/midiRebind" "Testing state, only usefull when not on a remote gui/midiRebind"
while True: while not self.fatal:
time.sleep(10) time.sleep(_TIMEOUT_HUGE)
def pingLoop(self):
"Another limbo wait, this time with pings"
while not self.fatal:
self._keepAlive()
time.sleep(_TIMEOUT_HUGE)
def keepPinging(self,timer=_TIMEOUT_HUGE):
"Keep pinging"
if self.fatal:
sys.exit()
threading.Timer(timer,self.keepPinging,(timer,)).start()
self._keepAlive()
# threading.Timer(self._keepPinging(timer),timer)
##################### #####################
# TESTING # TESTING
if __name__ == '__main__': if __name__ == '__main__':
_HOSTS=[["127.0.0.1",10500]] # Test server _HOSTS=[["127.0.0.1",3000]] # Test server
_TIMEOUT_HUGE=1
ctrl1=analogController(*_HOSTS[0]) ctrl1=analogController(*_HOSTS[0])
ctrl1.connectionSequence() ctrl1.connectionSequence()
ctrl1.limbowait() ctrl1.keepPinging()

View File

@ -1,33 +1,57 @@
def sequenceAnswers(seq): import socket
from _thread import start_new_thread
def sequenceAnswers(s,addr,seq):
try:
name=addr[1]
print("[{}] Connected".format(name))
# s.sendall("*\r\n".encode)
recv=b""
for elt,resps in seq:
elt=(elt+'\r\n').encode()
resps=[(i+'\r\n').encode() for i in resps]
print("[{}] Waiting for {}".format(name,elt))
while recv!=elt:
recv=s.recv(4095)
print("[{}] Received : {}".format(name,recv))
for r in resps:
print("[{}] Sending : {}".format(name,r))
s.sendall(r)
while True:
print(s.recv(4096).decode())
except ConnectionResetError as e:
print("[{}] Has stopped the connection".format(name))
print(e)
def Main(): def Main():
host = "127.0.0.1" host = "127.0.0.1"
# reverse a port on your computer # reverse a port on your computer
# in our case it is 12345 but it # in our case it is 12345 but it
# can be anything # can be anything
port = 10500 port = 3000
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind((host, port)) s.bind((host, port))
print("socket binded to port", port) print("Fake analogController (pulse2) on port ({})".format(port))
# put the socket into listening mode # put the socket into listening mode
s.listen(5) s.listen(5)
print("socket is listening") print("Server is listening to incomming connections")
# a forever loop until client wants to exit # a forever loop until client wants to exit
while True: while True:
# establish connection with client
c, addr = s.accept() c, addr = s.accept()
# Start a new thread and return its identifier # print(c.recv(4000))
start_new_thread(sequenceAnswers, (sequence,)) # c.sendall(b"*\r\n")
start_new_thread(sequenceAnswers, (c,addr,sequence,))
s.close() s.close()
if __name__ == '__main__': if __name__ == '__main__':
sequence=[ sequence=[
"" ("*",["*1"]),
] ("?",['DEV259']),
("VEvar",["VEvar13"]), #Guess
("#3",["PRinp0,1,7,8","PRinp0,1,1,8","#0"]), #Another guess
("1SYpig",["SYpig4294967294"]) #Another guess
]
Main() Main()