Fakeserver & merge

This commit is contained in:
Maximilien Rigaut 2021-09-30 19:40:35 +02:00
commit f88335fc7b
4 changed files with 493 additions and 100 deletions

View File

@ -1,2 +1,8 @@
# pythonAnalogWay
Python binds for analogway controllers
* TODO : If connect returns 0 wait another connect
* TODO : Verbosity levels
* TODO : Do something with all the value obtained
* TODO : Do a fakeserver

View File

@ -4,9 +4,9 @@
# IMPORTS
# import socketserver
import socket, threading
import sys
import sys,time
import re
from _thread import start_new_thread
################################
# CONFIG VARIABLES
_IPSELF = "192.168.0.140" # Could be usefull for multi IP networks
@ -15,12 +15,48 @@ _HOSTS = [("192.168.0.140",10500)]
_VERBOSE=True
_MSGSIZE=4096
_TIMEOUT=0.5
_MSG_ENDING=b"\r\n"
################################
# BIG DEFINES
_NO_FUNCT=lambda x:None
def _SYS_EXIT(system,*args):
system.fatal=True
sys.exit()
if _VERBOSE:
def dprint(*args):
print(*args)
def spec_print(spec,*args):
dprint("[pAW:{}]".format(spec),*args) #(line@{}) ,sys._getframe().f_lineno
def iprint(*args):
spec_print("INFO",*args)
def wprint(*args):
spec_print("WARNING",*args)
def eprint(*args):
spec_print("ERROR",*args)
else:
dprint=lambda x:None
dprint=_NO_FUNCT
wprint=_NO_FUNCT
eprint=_NO_FUNCT
iprint=_NO_FUNCT
class pyNope(object):
def __init__(self):
pass
def __call__(self,*args,**kwargs):
return self
def __repr__(self,*args,**kwargs):
return ''
def __getattr__(self,*args,**kwargs):
return self
################################
# VARIABLES
@ -86,6 +122,20 @@ _WAIT_DEVICE =re.compile('DEV(?P<device>\d*)')
_WAIT_VERSION=re.compile('VEvar(?P<version>\d*)')
_WAIT_STATUS=re.compile('#(?P<status>\d*)')
_WAIT_KPALIVE=re.compile('SYpig(?P<ping>\d*)')
# PROGRESS "PSprg99"
# GCfrl ?
# GCply
_MESSAGE_REGEX=re.compile("(?P<preargs>(\d)*(,\d)*)(?P<msg>\D*)(?P<postargs>(\d)*(,\d)*)")
_MATCHS={
"*":"CONNECT",
"DEV":"DEVICE",
"VEvar":"VERSION",
"#":"STATUS",
"SYpig":"KPALIVE",
"n":""
}
################################
# CLASS DEFINITIONS
@ -93,15 +143,27 @@ _WAIT_KPALIVE=re.compile('SYpig(?P<ping>\d*)')
class analogController(object):
"AnalogWay Controller, controls one AnalogWay device"
def __init__(self,ip,port):
def __init__(self,ip,port,feedbackInterface=pyNope()):
self.sck=None
self.ip=ip
self.port=port
self.running=True
self.listening=False
self.fatal=False
# Last received match messages
self.messages={i:None for i in ["CONNECT","DEVICE","VERSION","STATUS","KPALIVE","REGEX"]}
#
self.feedback=feedbackInterface # Feedback interface gui or midiRebind
self._LOCKS={i:threading.Lock() for i in [
"CONNECT","DEVICE","VERSION","STATUS","KPALIVE","changeLayer",
"takeAvailable","take","takeAll","loadMM","quickFrame","quickFrameAll"
]}
try:
dprint('[pAW:INFO] Creating socket')
iprint('Creating socket')
self.sck = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
dprint('[pAW:INFO] Getting remote IP address')
iprint('Getting remote IP address')
host=_IPSELF
remote_ip = socket.gethostbyname( host )
@ -112,34 +174,91 @@ class analogController(object):
print('[pAW:ERROR] Hostname could not be resolved. Exiting')
sys.exit()
################################
# MESSAGE RECEIVE
# def receive_CONNECT(self,match):
# "We received a connect message"
# self.messages["CONNECT"]=match
# self._LOCKS["connect"].release()
# self.feedback.messageReceived("CONNECT",match)
def receive_GENERIC(self,match):
"We received a connect message, all the logic will be on the feedback side"
try:
typ=_MATCHS[match.group("msg")]
self.messages[typ]=match #why not, not very clever tho
self._LOCKS[typ].release()
self.feedback.messageReceived("typ",match)
except RuntimeError as e:
iprint("Lock [{}] is already released (async terminated earlier)".format(typ))
iprint(e)
##############################################
# LOCKS
def waitLock(self,lockname,function_success=_NO_FUNCT,args_success=(),function_error=_NO_FUNCT,args_error=()):
"""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.start()
return thd
def _initLockWait(self,lockname,function_success=_NO_FUNCT,args_success=(),function_error=_NO_FUNCT,args_error=()):
"""Thread waiting for a lock"""
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
self._LOCKS[lockname].acquire(timeout=0.01)
# Now wait for the lock to be released
iprint("Acquired [{}] : Locking".format(lockname))
status=self._LOCKS[lockname].acquire(timeout=_TIMEOUT)
if status:
iprint("Lock [{}] passed succesfully".format(lockname))
function_success(args_success)
else:
iprint("Failed to aquire [{}]".format(lockname))
function_error(args_error)
return status
################################
# MESSAGES SUBROUTINS
def connect(self):
"""The device acts as a server. Once the TCP connection is established, the controller shall
check that the device is ready, by reading the READY status, until it returns the value 1.
[*] (* <value>) The controller shall wait and retry until it receives the value 1
"""
dprint('[pAW:INFO] Connecting to server, {self.ip}:{self.port}'.format(self=self))
iprint('Connecting to server, {self.ip}:{self.port}'.format(self=self))
self.sck.connect((self.ip,self.port))
dprint('[pAW:INFO] Sending data to server')
wait=self.waitLock("CONNECT",function_error=_SYS_EXIT,args_error=(self))
self.sendData("*\r\n")
ret=self.waitfor(_WAIT_CONNECT)
print(ret)
# iprint("Waiting for",wait)
wait.join()
if self.fatal:
_SYS_EXIT(self)
# iprint("Finished wait for",wait)
def getDevice(self):
"""This read only command gives the device type
[?] (DEV <value>) <values>:_DEVICES_VALUES
"""
iprint("Acquiring device type")
wait=self.waitLock("DEVICE",function_error=_SYS_EXIT,args_error=(self))
self.sendData("?")
ret=self.waitfor(_WAIT_DEVICE,"device")
print(ret)
wait.join()
if self.fatal:
_SYS_EXIT(self)
def getVersion(self):
"""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.
[VEvar] (VEvar<version>)
"""
iprint("Acquiring version")
wait=self.waitLock("VERSION",function_error=_SYS_EXIT,args_error=(self))
self.sendData("VEvar")
ret=self.waitfor(_WAIT_VERSION,"version")
print(ret)
wait.join()
if self.fatal:
_SYS_EXIT(self)
def getStatus(self,value=3):
"""Reading a change of values
@ -147,16 +266,12 @@ class analogController(object):
<value>:1 All register values 3: Only non default values
"""
self.sendData('#{}'.format(value))
ret=self.waitfor(_WAIT_STATUS)
print(ret)
def _keepAlive(self,val=1):
"""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
"""
self.sendData("{}SYpig".format(val))
ret=self.waitfor(_WAIT_KPALIVE)
print(ret)
def changeLayer(self,screen,ProgPrev,layer,src):
"""Change the layer of selected
@ -199,7 +314,6 @@ class analogController(object):
(GCtak<scrn>,1) : Take is available
(GCtak<scrn>,1) : Take is available
"""
pass
def loadMM(screenF,memory,screenT,ProgPrev,filter):
@ -231,31 +345,68 @@ class analogController(object):
def connectionSequence(self):
"Execute the full connection sequence"
self.start_listening()
self.connect()
self.getDevice()
self.getVersion()
self.getStatus()
# self.getVersion()
# self.getStatus()
def waitfor(self,value,*matchgroups):
"""Wait for a specific return value, blocking"""
notfound=True
returndict={}
while notfound:
#########################################
# SOCKET METHODS
def start_listening(self):
"""Start the loop listener"""
if self.listening:
return
start_new_thread(self.socketLoop,())
def cleanReceive(self):
"Yield only clean messages"
self.running=True
reply_bytes=b""
while self.running:
try:
reply=self.sck.recv(_MSGSIZE)
dprint ("[pAW:INFO] Received:",reply)
RX_MTCH=value.match(reply.decode())
for grp in matchgroups:
returndict[grp]=RX_MTCH.group(grp)
# f = open("datadump.txt", "ab+")
received=self.sck.recv(_MSGSIZE)
# f.write(received)
# f.close()
reply_bytes+=received
if reply_bytes.find(_MSG_ENDING)==-1: # Message is not finished
continue
else:
reply,reply_bytes=reply_bytes.rsplit(_MSG_ENDING,1)
reply=(reply+_MSG_ENDING).decode().split("\r\n")
for r in reply[:-1]: # iprint("Yielding:",r)
yield r
except AttributeError as e:
dprint(e)
def socketLoop(self):
"""Loop on the socket and create an event for every message received"""
self.listening=True
for message in self.cleanReceive():
try:
iprint ("Received:",message)
RX_MTCH=_MESSAGE_REGEX.match(message)
iprint("preargs:{} - msg:{} - postargs:{}".format(RX_MTCH.group("preargs"),RX_MTCH.group("msg"),RX_MTCH.group("postargs")))
start_new_thread(self.processMatch,(RX_MTCH,))
except AttributeError as e:
dprint("[pAW:ERROR] Regex couldn't find a match")
dprint(e)
except Exception as e:
print(e)
return returndict
# except:
# pass
def processMatch(self,match):
"""Process a match with a message, should only be called by the socketLoop funciton"""
try:
name=_MATCHS[match.group("msg")]
# self.__getattribute__("receive_{}".format(name),default="GENERIC")(match)
self.receive_GENERIC(match)
except KeyError as e:
dprint("[pAW:ERROR] Can't find matched key:",match)
print(e)
def sendData(self,data):
"Send data through the socket"
@ -265,73 +416,15 @@ class analogController(object):
print ('[pAW:ERROR] Send failed of data :',data)
sys.exit()
def limbowait(self):
"Testing state, only usefull when not on a remote gui/midiRebind"
while True:
time.sleep(10)
#####################
# TESTING
if __name__ == '__main__':
_HOSTS=[["127.0.0.1",10500]] # Test server
ctrl1=analogController(*_HOSTS[0])
ctrl1.connectionSequence()
# ctrl1.waitfor("")
# except ConnectionRefusedError:
# # Receive data
# print('# Receive data from server')
# while True:
# reply = s.recv(4096)
#
# print (reply)
# # thread function
# def threaded(c):
# while True:
#
# # data received from client
# data = c.recv(1024)
# if not data:
# print('Bye')
#
# # lock released on exit
# print_lock.release()
# break
#
# # reverse the given string from client
# data = data[::-1]
#
# # send back reversed string to client
# c.send(data)
#
# # connection closed
# c.close()
#
#
# def Main():
# host = ""
#
# # reverse a port on your computer
# # in our case it is 12345 but it
# # can be anything
# port = 12345
# s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# s.bind((host, port))
# print("socket binded to port", port)
#
# # put the socket into listening mode
# s.listen(5)
# print("socket is listening")
#
# # a forever loop until client wants to exit
# while True:
#
# # establish connection with client
# c, addr = s.accept()
#
# # lock acquired by client
# print_lock.acquire()
# print('Connected to :', addr[0], ':', addr[1])
#
# # Start a new thread and return its identifier
# start_new_thread(threaded, (c,))
# s.close()
#
#
# if __name__ == '__main__':
# Main()
ctrl1.limbowait()

291
datadump.txt Normal file
View File

@ -0,0 +1,291 @@
*1
DEV259
PRinp0,1,1,7
PUscu0,1
GCtav0,0
CTsto1
PRinp0,1,7,6
PRinp0,1,1,6
PUscu0,1
CTsto0
GCtav0,1
AUoci1,12
GCtav0,0
CTsto1
PRinp0,1,7,8
PRinp0,1,1,8
PUscu0,1
CTsto0
GCtav0,1
AUoci1,14
GCtav0,0
CTsto1
PRinp0,1,7,4
PRinp0,1,1,4
PUscu0,1
CTsto0
AUoci1,0
GCtav0,1
GCtav0,0
CTsto1
PRinp0,1,7,3
PRinp0,1,1,3
PUscu0,1
GCtav0,1
CTsto0
GCtav0,0
CTsto1
PRinp0,1,7,2
PRinp0,1,1,2
PUscu0,1
AUoci1,9
GCtav0,1
CTsto0
GCtav0,0
CTsto1
PRinp0,1,7,1
PRinp0,1,1,1
PUscu0,1
GCtav0,1
AUoci1,6
AUoci1,1
CTsto0
GCtav0,0
CTsto1
PRinp0,1,7,5
PRinp0,1,1,5
PUscu0,1
GCtav0,1
CTsto0
AUoci1,11
GCtav0,0
CTsto1
PRinp0,1,7,6
PRinp0,1,1,6
PUscu0,1
CTsto0
GCtav0,1
AUoci1,12
GCply2
GCtav0,0
CTsto1
PRinp0,1,7,1
PRinp0,1,2,1
PUscu0,1
GCtav0,1
CTsto0
AUoci1,1
GCtav0,0
CTsto1
PRinp0,1,7,2
PRinp0,1,2,2
PUscu0,1
GCtav0,1
CTsto0
AUoci1,6
GCtav0,0
CTsto1
PRinp0,1,7,3
PRinp0,1,2,3
PUscu0,1
CTsto0
GCtav0,1
GCtav0,0
CTsto1
PRinp0,1,7,4
PRinp0,1,2,4
PUscu0,1
CTsto0
AUoci1,9
GCtav0,1
AUoci1,0
GCtav0,0
CTsto1
PRinp0,1,7,8
PRinp0,1,2,8
PUscu0,1
CTsto0
GCtav0,1
GCtav0,0
CTsto1
PRinp0,1,7,7
PRinp0,1,2,7
PUscu0,1
GCtav0,1
CTsto0
AUoci1,14
AUoci1,13
GCtav0,0
CTsto1
PRinp0,1,7,6
PRinp0,1,2,6
PUscu0,1
GCtav0,1
CTsto0
GCtav0,0
CTsto1
PRinp0,1,7,5
PRinp0,1,2,5
PUscu0,1
AUoci1,12
GCtav0,1
CTsto0
AUoci1,11
GCply0
GCtav0,0
CTsto1
PRinp0,1,0,1
PUscu0,1
CTsto0
GCtio0,1
GCtav0,1
GCtav0,0
CTsto1
PRinp0,1,0,2
PUscu0,1
GCtav0,1
CTsto0
GCtav0,0
CTsto1
PRinp0,1,0,3
PUscu0,1
GCtav0,1
CTsto0
GCtav0,0
CTsto1
PRinp0,1,0,4
PUscu0,1
GCtav0,1
CTsto0
GCtav0,0
CTsto1
PRinp0,1,0,5
PUscu0,1
GCtio0,0
GCtav0,1
CTsto0
GCtak0,1
GCtav0,0
AUoci0,11
CTsto1
PRinp0,2,0,5
PRinp0,2,1,7
PRinp0,2,7,7
PRinp0,0,1,6
PRinp0,0,2,5
PRinp0,0,7,5
GCtak0,0
GCtav0,1
CTsto0
PSmod2
PSidx0
PSidx0
PSidx1
PSexe1
CTsto1
PSfrv1,0
PSfsh1,0
PSfsv1,0
CTsto0
PSsta3
PSprg1
PSprg2
PSprg3
PSprg4
PSprg5
PSprg6
PSprg8
PSprg9
PSprg10
PSprg11
PSprg12
PSprg13
PSprg15
PSprg16
PSprg17
PSprg18
PSprg19
PSprg20
PSprg22
PSprg23
PSprg25
PSprg26
PSprg28
PSprg29
PSprg30
PSprg31
PSprg33
PSprg34
PSprg35
PSprg36
PSprg37
PSprg39
PSprg40
PSprg41
PSprg42
PSprg44
PSprg45
PSprg46
PSprg47
PSprg48
PSsta0
PSsta2
PSprg51
PSprg52
PSprg53
PSprg55
PSprg56
PSprg57
PSprg59
PSprg60
PSprg61
PSprg62
PSprg64
PSprg65
PSprg66
PSprg68
PSprg69
PSprg70
PSprg71
PSprg73
PSprg74
PSprg75
PSprg77
PSprg78
PSprg80
PSprg81
PSprg82
PSprg84
PSprg85
PSprg86
PSprg88
PSprg89
PSprg91
PSprg92
PSprg94
PSprg95
PSprg96
PSprg98
PSprg99
PSsta0
PSprg100
CTsto1
PSfsh1,1920
PSfsv1,1080
PSfrv1,1
PSprg0
PSexe0
CTsto0
PSmod0
GCtak0,1
GCtav0,0
CTsto1
PRinp0,2,1,6
PRinp0,2,2,5
PRinp0,2,7,5
GCtak0,0
GCtav0,1
CTsto0
CTqfa0,1
CTqfa0,0

View File

@ -27,4 +27,7 @@ def Main():
if __name__ == '__main__':
sequence=[
""
]
Main()