def test_oscclient(): osc = OSCThreadServer() sock = osc.listen() port = sock.getsockname()[1] acc = [] def success(*values): acc.append(values[0]) osc.bind(b'/success', success, sock) client = OSCClient('localhost', port) timeout = time() + 5 while len(acc) < 50: if time() > timeout: raise OSError('timeout while waiting for success message.') client.send_message(b'/success', [1]) while len(acc) < 100: if time() > timeout: raise OSError('timeout while waiting for success message.') client.send_bundle([(b'/success', [i]) for i in range(10)])
def test_bind_multi(): osc = OSCThreadServer() sock1 = osc.listen() port1 = sock1.getsockname()[1] sock2 = osc.listen() port2 = sock2.getsockname()[1] cont = [] def success1(*values): cont.append(True) def success2(*values): cont.append(False) osc.bind(b'/success', success1, sock1) osc.bind(b'/success', success2, sock2) send_message(b'/success', [b'test', 1, 1.12345], 'localhost', port1) send_message(b'/success', [b'test', 1, 1.12345], 'localhost', port2) timeout = time() + 5 while len(cont) < 2: if time() > timeout: raise OSError('timeout while waiting for success message.') assert True in cont and False in cont
def setup_service(): Logger.info('service: setup_service') setup_logger('mi') # add this dir to module search path app_dir = os.path.join(mi2app_utils.get_files_dir(), "app") sys.path.append(os.path.join(app_dir, 'service')) Logger.info('service: sys path added: ' + str(sys.path)) # setup control and listen to osc signal control = Control() Logger.info('service: control created' + repr(control)) osc = OSCThreadServer() osc.listen(port=OSCConfig.service_port, default=True) # def dummy_callback(msg, *args): # Logger.info('service: dummy callback: ' + str(msg)) # osc.bind(OSCID, dummy_callback, OSCConfig.control_addr) osc.bind(bytes(OSCConfig.control_addr, "ascii"), control.osc_callback) # Logger.info('service: osc setup, id: ' + OSCID) Logger.info('service: osc setup') gps_provider = GpsListener(on_gps) gps_provider.start() osc_client = OSCClient("127.0.0.1", OSCConfig.service_port) osc_client.send_message(bytes(OSCConfig.control_addr, "ascii"), ['service ready',]) Logger.info('service SEND>: service ready msg sent') while True: # osc.readQueue(thread_id=OSCID) time.sleep(.5)
def test_server_different_port(): # server, will be tested: server_3000 = OSCThreadServer(encoding='utf8') sock_3000 = server_3000.listen(address='0.0.0.0', port=3000, default=True) server_3000.bind(b'/callback_3000', callback_3000) # clients sending to different ports, used to test the server: client_3000 = OSCClient(address='localhost', port=3000, encoding='utf8') # server sends message to himself, should work: server_3000.send_message(b'/callback_3000', ["a"], ip_address='localhost', port=3000) sleep(0.05) # client sends message to server, will be received properly: client_3000.send_message(b'/callback_3000', ["b"]) sleep(0.05) # sever sends message on different port, might crash the server on windows: server_3000.send_message(b'/callback_3000', ["nobody is going to receive this"], ip_address='localhost', port=3001) sleep(0.05) # client sends message to server again. if server is dead, message will not be received: client_3000.send_message(b'/callback_3000', ["c"]) sleep(0.1) # give time to finish transmissions # if 'c' is missing in the received checklist, the server thread crashed and could not recieve the last message from the client: assert checklist == ['a', 'b', 'c'] server_3000.stop() # clean up
def test_bind_no_default(): osc = OSCThreadServer() def success(*values): pass with pytest.raises(RuntimeError) as e_info: # noqa osc.bind(b'/success', success)
def receive_values_from_max(ip, port): while (1): osc = OSCThreadServer() sock = osc.listen(address=ip, port=port, default=True) #osc.bind(b'/crowd-accel',acceleration_data) osc.bind(b'/crowd-pos', positional_data) sleep(1) osc.stop() return True
def receive_values_from_max(ip, port): while (1): osc = OSCThreadServer() sock = osc.listen(address=ip, port=port, default=True) osc.bind(b'/density', printer) osc.bind(b'/cluster', printer) osc.bind(b"/mob_speed", printer) sleep(1000) osc.stop() return True
def start_osc(self): global osc def callback(*values): print("<<<<<<>>>>>> got values: {}".format(values)) print("STARTING OSC SERVER>>>>>>>>>>>>>>>>>") osc = OSCThreadServer() sock = osc.listen(address='0.0.0.0', port=8888, default=True) osc.bind(b'/address', callback)
def test_reuse_callback(): osc = OSCThreadServer() sock = osc.listen() port = sock.getsockname()[1] cont = [] def success(*values): cont.append(True) osc.bind(b'/success', success, sock) osc.bind(b'/success', success, sock) osc.bind(b'/success2', success, sock) assert len(osc.addresses.get((sock, b'/success'))) == 1 assert len(osc.addresses.get((sock, b'/success2'))) == 1
class ctrlOSC(object): def __init__(self): super(ctrlOSC, self).__init__() # self.isrunning = True self.osc = OSCThreadServer() self.sock = self.osc.listen(address='0.0.0.0', port=8000, default=True) self.osc.bind(b'/address', self.callback) # def run(self): # while self.isrunning: # @osc.address(b'/address') def callback(self, values, *args): print("got values: {}, {}, {}".format(type(values), values, args))
class OSC: """Ne fait que envoyer avec self.client et recevoir avec self.server, en com avec service.py """ def __init__(self): self.sensor = "\nRecherche d'un capteur ..." # a, b, c, activity, num, tempo self.display_list = [0, 0, 0, 0, 0, 1, 0] # Conservation de tout l'historique self.histo_xyz = [] self.server = OSCThreadServer() self.server.listen(address=b'localhost', port=3003, default=True) self.server.bind(b'/acc', self.on_acc) self.server.bind(b'/sensor', self.on_sensor) self.server.bind(b'/offset', self.on_offset) self.client = OSCClient(b'localhost', 3001) self.t_init = None def on_offset(self, offset): """Valeur possible: Android Virtual No sensor""" self.offset = offset * 1000000 print("self.offset =", self.offset) def on_sensor(self, sens): """Valeur possible: Android Virtual No sensor""" self.sensor = sens.decode('utf-8') def on_acc(self, *args): # Nessressaire pour maj affichage si acc ne tourne pas self.display_list = [ args[0], args[1], args[2], args[3], args[4], args[5], args[6] ] a, b, c, t = (args[0], args[1], args[2], args[6]) # dans service: t=int(time()*1000)-1604000000000 avec get_datetime() t_absolute = get_datetime(t, self.offset) # Datetime du début if not self.t_init: self.t_init = t_absolute t_relativ = t_absolute - self.t_init # En secondes tx = t_relativ.total_seconds() norme = int((a**2 + b**2 + c**2)**0.5) # Par axe if norme > 1: # Bug au début self.histo_xyz.append((tx, (a, b, c)))
def test_bind_default(): osc = OSCThreadServer() osc.listen(default=True) port = osc.getaddress()[1] cont = [] def success(*values): cont.append(True) osc.bind(b'/success', success) send_message(b'/success', [b'test', 1, 1.12345], 'localhost', port) timeout = time() + 5 while not cont: if time() > timeout: raise OSError('timeout while waiting for success message.')
def test_send_message(): osc = OSCThreadServer() sock = osc.listen() port = sock.getsockname()[1] acc = [] def success(*values): acc.append(values[0]) osc.bind(b'/success', success, sock) timeout = time() + 5 while len(acc) < 100: if time() > timeout: raise OSError('timeout while waiting for success message.') send_message(b'/success', [1], 'localhost', port)
def test_bind_get_address_smart(): osc = OSCThreadServer(advanced_matching=True) sock = osc.listen() port = sock.getsockname()[1] cont = [] def success(address, *values): assert address == b'/success/a' cont.append(True) osc.bind(b'/success/?', success, sock, get_address=True) send_message(b'/success/a', [b'test', 1, 1.12345], 'localhost', port) timeout = time() + 5 while not cont: if time() > timeout: raise OSError('timeout while waiting for success message.')
def test_unbind_default(): osc = OSCThreadServer() sock = osc.listen(default=True) port = sock.getsockname()[1] cont = [] def failure(*values): cont.append(True) osc.bind(b'/failure', failure) osc.unbind(b'/failure', failure) send_message(b'/failure', [b'test', 1, 1.12345], 'localhost', port) timeout = time() + 1 while time() > timeout: assert not cont sleep(10e-9)
def test_unbind(): osc = OSCThreadServer() sock = osc.listen() port = sock.getsockname()[1] cont = [] def failure(*values): cont.append(True) osc.bind(b'/failure', failure, sock) with pytest.raises(RuntimeError) as e_info: # noqa osc.unbind(b'/failure', failure) osc.unbind(b'/failure', failure, sock) send_message(b'/failure', [b'test', 1, 1.12345], 'localhost', port) timeout = time() + 1 while time() > timeout: assert not cont sleep(10e-9)
class OSC: """Ne fait que envoyer avec self.client et recevoir avec self.server, en com avec service.py """ def __init__(self): self.sensor = "Recherche d'un capteur ..." # a, b, c, activity, num, tempo self.display_list = [0, 0, 0, -2, 0, 1, 0] self.histo = [] self.server = OSCThreadServer() self.server.listen(address=b'localhost', port=3003, default=True) self.server.bind(b'/acc', self.on_acc) self.server.bind(b'/sensor', self.on_sensor) self.client = OSCClient(b'localhost', 3001) self.t_init = 0 def on_sensor(self, sens): """Vlaleur possible: Andoid Virtual No sensor""" self.sensor = sens.decode('utf-8') def on_acc(self, *args): self.display_list = args a, b, c, t = (self.display_list[0], self.display_list[1], self.display_list[2], self.display_list[6]) norme = int((a**2 + b**2 + c**2)**0.5) # 920736845 # 36845 if self.t_init: tx = (t - self.t_init) / 100 else: self.t_init = t tx = 0 print(tx) # liste de couple (x, y) self.histo.append((tx, norme)) if len(self.histo) > 100: del self.histo[0]
def test_intercept_errors(caplog): cont = [] def success(*values): cont.append(True) def broken_callback(*values): raise ValueError("some bad value") osc = OSCThreadServer() sock = osc.listen() port = sock.getsockname()[1] osc.bind(b'/broken_callback', broken_callback, sock) osc.bind(b'/success', success, sock) send_message(b'/broken_callback', [b'test'], 'localhost', port) sleep(0.01) send_message(b'/success', [b'test'], 'localhost', port) assert not osc.join_server(timeout=0.02) # Thread not stopped assert cont == [True] assert len(caplog.records) == 1, caplog.records record = caplog.records[0] assert record.msg == "Unhandled exception caught in oscpy server" assert not record.args assert record.exc_info osc = OSCThreadServer(intercept_errors=False) sock = osc.listen() port = sock.getsockname()[1] osc.bind(b'/broken_callback', broken_callback, sock) send_message(b'/broken_callback', [b'test'], 'localhost', port) assert osc.join_server( timeout=0.02) # Thread properly sets termination event on crash assert len(caplog.records) == 1, caplog.records # Unchanged
class tstick: # Creating variables to define T-Stick mapping # This variable will be defined when we receive # T-Stick info. instrument_name = "T-Stick" tstick_id = 0 def __init__(self, serialport, ip, port, networkinterface, listenport): # set listening ip to receive OSC messages self.local_ip = ni.ifaddresses( args.networkinterface)[ni.AF_INET][0]['addr'] # Set OSC client and server self.server_osc = OSCThreadServer() self.sock = self.server_osc.listen(address=self.local_ip, port=listenport, default=True) self.client_osc = OSCClient(ip, port) # Opening T-Stick serial port self.tstick_serial_port = serial.Serial(serialport, 115200, dsrdtr=1) # routing OSC signals self.server_osc.bind(b'/status', self.resend) def osc_send(self, sensor_data): if sensor_data: for i in range(len(sensor_data)): if isinstance(sensor_data[i], list): # has to be list data = data_lib = sensor_data[i] if not isinstance(sensor_data[i], list): data_lib = sensor_data[i] # for libmapper data = [sensor_data[i]] # adding [] if its not list sensor_name = sensor_data._fields[i] self.client_osc.send_message(b'/{}'.format(sensor_name), data) def resend(self, *values): self.tstick_serial_port.write(values) def heartbeat(self): self.tstick_serial_port.write('s'.encode('utf-8')) def receive_and_send_serial(self): """ Receive T-Stick serial data and make it available as "serial_data" variable. The data is namedtuple. Also sends serial data to T-Stick (receives OSC from client). """ flag = False msg = [] while True: # byte = int.from_bytes(TSTICK.read(), sys.byteorder) # python 3.2+ if sys.byteorder == 'little': byte = struct.unpack("<B", self.tstick_serial_port.read()) else: byte = struct.unpack(">B", self.tstick_serial_port.read()) byte = byte[0] if not flag: if byte == 100: information = self.get_tstick_id(*msg) self.osc_send(information) if (self.tstick_id == 173): serial_data = self.sort_173(*msg) self.osc_send(serial_data) elif (self.tstick_id == 10 or self.tstick_id == 12 or self.tstick_id == 24 or self.tstick_id == 171): serial_data = self.sort_2G(*msg) self.osc_send(serial_data) elif (self.tstick_id == 15): serial_data = self.sort_2GX(*msg) self.osc_send(serial_data) del msg[:] elif byte == 101: flag = True else: msg.append(byte) else: msg.append(byte) flag = False def bit_conversion(self, byte1, byte2): return (byte1 * 256) + byte2 def bit_ext_conversion(self, byte1, byte2): bin_or = (byte1 * 256) | byte2 return bin_or - (65535 * (bin_or > 32767)) def get_tstick_id(self, *msg): named_return = collections.namedtuple('tstick_information', 'information') if len(msg) < 1: return False if msg[0] == 0: if len(msg) < 5: return False self.tstick_id = self.bit_conversion(msg[1], msg[2]) firmware = self.bit_conversion(msg[3], msg[4]) info_list = [self.tstick_id, firmware] if len(msg) > 5: for i in msg[5:]: info_list.append(i) return named_return(info_list) def sort_173(self, *msg): """ Route T-Stick messages for T-Stick #173. """ if msg[0] == 0: return False elif msg[0] == 1: named_return = collections.namedtuple('tstick_sensor', 'rawcapsense') rawcapsense = msg[1:] return named_return(list(rawcapsense)) elif msg[0] == 2: named_return = collections.namedtuple( 'tstick_sensor', 'rawaccel rawgyro rawpressure rawpiezo') if len(msg) < 17: return False accel_x = self.bit_ext_conversion(msg[1], msg[2]) accel_y = self.bit_ext_conversion(msg[3], msg[4]) accel_z = self.bit_ext_conversion(msg[5], msg[6]) gyro_x = self.bit_ext_conversion(msg[7], msg[8]) gyro_y = self.bit_ext_conversion(msg[9], msg[10]) gyro_z = self.bit_ext_conversion(msg[11], msg[12]) pressure = self.bit_ext_conversion(msg[13], msg[14]) piezo = self.bit_ext_conversion(msg[15], msg[16]) return named_return([accel_x, accel_y, accel_z], [gyro_x, gyro_y, gyro_z], pressure, piezo) elif msg[0] == 3: named_return = collections.namedtuple('tstick_sensor', 'rawmag') if len(msg) < 7: return False mag_x = self.bit_ext_conversion(msg[1], msg[2]) mag_y = self.bit_ext_conversion(msg[3], msg[4]) mag_z = self.bit_ext_conversion(msg[5], msg[6]) return named_return([mag_x, mag_y, mag_z]) elif msg[0] == 4: return False def sort_2G(self, *msg): """ Route T-Stick messages for T-Stick 2G series: 010, 012, 024, 171. """ if msg[0] == 0: return False elif msg[0] == 1: named_return = collections.namedtuple('tstick_sensor', 'rawcapsense') rawcapsense = msg[1:] return named_return(list(rawcapsense)) elif msg[0] == 2: named_return = collections.namedtuple('tstick_sensor', 'rawjab') rawjab = msg[1:] return named_return(list(rawjab)) elif msg[0] == 3: named_return = collections.namedtuple('tstick_sensor', 'rawtap') rawtap = msg[1:] return named_return(list(rawtap)) elif msg[0] == 4: named_return = collections.namedtuple( 'tstick_sensor', 'rawaccel rawpressure rawpiezo') if len(msg) < 11: return False accel_x = self.bit_conversion(msg[1], msg[2]) accel_y = self.bit_conversion(msg[3], msg[4]) accel_z = self.bit_conversion(msg[5], msg[6]) pressure = self.bit_conversion(msg[7], msg[8]) piezo = self.bit_conversion(msg[9], msg[10]) return named_return([accel_x, accel_y, accel_z], pressure, piezo) def sort_2GX(*msg): """ Route T-Stick messages for T-Stick #015. """ if msg[0] == 0: return False elif msg[0] == 1: named_return = collections.namedtuple('tstick_sensor', 'rawcapsense') rawcapsense = msg[1:] return named_return(list(rawcapsense)) # capsense_bits = cook_touch_soprano(*rawcapsense) elif msg[0] == 2: named_return = collections.namedtuple('tstick_sensor', 'rawjab') rawjab = msg[1:] return named_return(list(rawjab)) elif msg[0] == 3: named_return = collections.namedtuple('tstick_sensor', 'rawtap') rawtap = msg[1:] return named_return(list(rawtap)) elif msg[0] == 4: named_return = collections.namedtuple( 'tstick_sensor', 'rawaccel rawpressure rawpiezo rawairpressure rawrange rawldr1 rawldr2' ) if len(msg) < 19: return False accel_x = self.bit_conversion(msg[1], msg[2]) accel_y = self.bit_conversion(msg[3], msg[4]) accel_z = self.bit_conversion(msg[5], msg[6]) pressure = self.bit_conversion(msg[7], msg[8]) piezo = self.bit_conversion(msg[9], msg[10]) airpressure = self.bit_conversion(msg[11], msg[12]) tstick_range = self.bit_conversion(msg[13], msg[14]) ldr1 = self.bit_conversion(msg[15], msg[16]) ldr2 = self.bit_conversion(msg[17], msg[18]) return named_return([accel_x, accel_y, accel_z], pressure, piezo, airpressure, tstick_range, ldr1, ldr2) def cook_touch_soprano(self, *bytes): byte_list = "" for byte in bytes: byte_list = byte_list + format(byte, '08b') return list(byte_list) def wakeup(self): """ Setting heartbeat to run every second """ scheduler = BackgroundScheduler() scheduler.add_job(self.heartbeat, 'interval', seconds=1) scheduler.start()
def ping(*_): 'answer to ping messages' CLIENT.send_message( b'/message', [ ''.join(sample(ascii_letters, randint(10, 20))).encode('utf8'), ], ) def send_date(): 'send date to the application' CLIENT.send_message( b'/date', [ asctime(localtime()).encode('utf8'), ], ) #if __name__ == '__main__': SERVER = OSCThreadServer() SERVER.listen('localhost', port=3000, default=True) SERVER.bind(b'/ping', ping) for i in range(30): sleep(1) send_date() sleep(50)
CLIENT = OSCClient('localhost', 3002) def ping(*_): 'answer to ping messages' CLIENT.send_message( b'/message', [ ''.join(sample(ascii_letters, randint(10, 20))) .encode('utf8'), ], ) def send_date(): 'send date to the application' CLIENT.send_message( b'/date', [asctime(localtime()).encode('utf8'), ], ) if __name__ == '__main__': SERVER = OSCThreadServer() SERVER.listen('localhost', port=3000, default=True) SERVER.bind(b'/ping', ping) while True: sleep(1) send_date()
class AccelerometerService: def __init__(self): self.loop = 1 self.status = 0 self.status_msg = "" self.sensor_enabled = 0 # 1=android acc, 2=virtualacc self.num = 0 self.init_acc() self.virtual_acceler = None self.activity = -2 self.stop = 0 self.init_dir() self.init_osc() self.sensor_init() def init_osc(self): """Le serveur peut envoyer mais impossible d'avoir 2 serveurs sur le même port. """ self.server = OSCThreadServer() self.server.listen('localhost', port=3001, default=True) # Les callbacks du serveur self.server.bind(b'/activity', self.on_activity) self.server.bind(b'/stop', self.on_stop) self.server.bind(b'/sensor_enable', self.on_sensor_enable) # Un simple client self.client = OSCClient(b'localhost', 3003) def on_activity(self, msg): print("activity", msg) self.activity = int(msg) def on_stop(self, msg): print("stop", msg) self.loop = int(msg) def init_dir(self): # Création du dossier d'enregistrement if ANDROID: extern = storagepath.get_documents_dir() else: extern = "." dt = datetime.now().strftime("%Y_%m_%d_%H_%M_%S") self.my_path_directory = f"{extern}/accelerometer/acc_{dt}" print(f"Documents Storage = {extern}") print(f"Dossier d'enregistrement des datas = {self.my_path_directory}") create_dir(self.my_path_directory) def init_acc(self): self.acc_x = np.zeros((500, ), dtype=int) self.acc_y = np.zeros((500, ), dtype=int) self.acc_z = np.zeros((500, ), dtype=int) self.acc_act = np.zeros((500, ), dtype=int) def sensor_init(self): """accelerometer est une variable globale""" print("Lancement de l'accéléromètre...") if self.sensor_enabled == 0: if ANDROID: try: accelerometer.enable() sleep(1) self.sensor_enabled = 1 self.status_msg = "Stop Accelerometer" print("Android sensor enable") except: accelerometer.disable() self.sensor_enabled = 0 print("Android sensor doesn't work!") self.status_msg = "Android sensor doesn't work!" else: # Linux self.status_msg = "Stop Virtual Accelerometer" self.sensor_enabled = 2 self.virtual_acceler = VirtualAccelerometer() print("Virtual sensor enabled") # Display if self.sensor_enabled == 1: sens = "Andoid sensor enable" elif self.sensor_enabled == 2: sens = "Virtual sensor enabled" else: sens = "No sensor" self.client.send_message(b'/sensor', [sens.encode('utf-8')]) def on_sensor_enable(self, msg): """Appelé si actionné dans main avec start et stop accelerometer""" self.status = int(msg) def get_acceleration(self): if self.status: a, b, c = 0, 0, 0 if self.sensor_enabled == 1: val = accelerometer.acceleration[:3] if not val == (None, None, None): a = int(val[0] * 1000) b = int(val[1] * 1000) c = int(val[2] * 1000) elif self.sensor_enabled == 2: self.virtual_acceler.random_acc() a = self.virtual_acceler.x b = self.virtual_acceler.y c = self.virtual_acceler.z else: sleep(1) print("Aucun accéléromètre activé !") if self.sensor_enabled != 0: # Set dans les arrays self.acc_x[self.num] = a self.acc_y[self.num] = b self.acc_z[self.num] = c self.acc_act[self.num] = self.activity acc_message = [a, b, c, self.activity, self.num] self.client.send_message(b'/acc', acc_message) self.num += 1 # Fin d'un fichier if self.num >= 500: if self.activity >= 0: dt = datetime.now().strftime("%Y_%m_%d_%H_%M_%S") outfile = f"{self.my_path_directory}/acc_{dt}.npz" np.savez_compressed( outfile, **{ "x": self.acc_x, "y": self.acc_y, "z": self.acc_z, "activity": self.acc_act }) print(f"Enregistrement de: {outfile}") self.client.send_message(b'/file', [outfile.encode('utf-8')]) else: a = "Pas d'activité définie" self.client.send_message(b'/file', [a.encode('utf-8')]) self.num = 0 self.init_acc() def run(self): while self.loop: self.get_acceleration() sleep(0.02)
class AccelerometerService: def __init__(self): self.tempo = 0.1 self.freq = 10 self.real_freq = 2 self.loop = 1 self.status = 0 self.sensor_enabled = 0 # 1=android acc, 2=virtualacc self.num = 0 self.t_0 = time() self.init_acc() self.virtual_acceler = None self.activity = 0 self.stop = 0 self.init_dir() self.init_osc() self.offset = self.get_offset() self.sensor_init() def get_offset(self): """ 1604917632133 > maxi pour osc = 2 147 483 648 = 2 * 10exp9 1606230010010 1606000000000 """ offset = int(time()/1000000)*1000000000 print("offset =", offset, "Envoi de:", int(offset/1000000)) self.client.send_message(b'/offset', [int(offset/1000000)]) return offset def init_dir(self): # Création du dossier d'enregistrement if ANDROID: extern = storagepath.get_documents_dir() else: extern = "." dt = datetime.now().strftime("%Y_%m_%d_%H_%M_%S") self.my_path_directory = f"{extern}/accelerometer/acc_{dt}" print(f"Documents Storage = {extern}") print(f"Dossier d'enregistrement des datas = {self.my_path_directory}") create_dir(self.my_path_directory) def init_acc(self): self.acc_x = np.zeros((1,), dtype=int) self.acc_y = np.zeros((1,), dtype=int) self.acc_z = np.zeros((1,), dtype=int) self.acc_act = np.zeros((1,), dtype=int) self.acc_time = np.zeros((1,), dtype=int) def sensor_init(self): """accelerometer est une variable globale, non reconnue par le thread""" print("Lancement de l'accéléromètre...") if self.sensor_enabled == 0: if ANDROID: # #while self.sensor_enabled == 1: # #sleep(2) try: accelerometer.enable() sleep(1) self.sensor_enabled = 1 # #self.status_msg = "Stop Accelerometer" print("Android sensor enable") except: accelerometer.disable() self.sensor_enabled = 0 print("Android sensor doesn't work!") # #self.status_msg = "Android sensor doesn't work!" else: # Linux self.status_msg = "Stop Virtual Accelerometer" self.sensor_enabled = 2 self.virtual_acceler = VirtualAccelerometer() print("Virtual sensor enabled") # Display if self.sensor_enabled == 1: sens = "Android" elif self.sensor_enabled == 2: sens = "Virtual" else : sens = "No sensor" self.client.send_message(b'/sensor', [sens.encode('utf-8')]) def init_osc(self): self.server = OSCThreadServer() self.server.listen('localhost', port=3001, default=True) self.server.timeout = 0.001 self.server.bind(b'/activity', self.on_activity) self.server.bind(b'/stop', self.on_stop) self.server.bind(b'/sensor_enable', self.on_sensor_enable) self.server.bind(b'/frequency', self.on_frequency) self.server.bind(b'/save_npz', self.on_save_npz) self.client = OSCClient(b'localhost', 3003) def on_frequency(self, msg): print("Valeur de frequency reçue dans service=", msg) self.freq = int(msg) tempo = (1 / int(msg)) self.tempo = float(tempo) print(" nouvelle tempo =", round(tempo, 3)) self.init_acc() self.num = 0 def on_activity(self, msg): print("Nouvelle valeur pour activity =", msg) self.activity = int(msg) # 1604917632133 > maxi pour osc = 2 147 483 648 = 2 * 10exp9 t = time() # 1606230010010 # 1606000000000 tp = int(t*1000) - self.offset acc_message = [0, 0, 0, self.activity, self.num, self.tempo, tp] # Mise à jour de l'affichage, même si acc ne tourne pas # #print("acc_message =", acc_message) self.client.send_message(b'/acc', acc_message) def on_stop(self, msg): print("stop =", msg) accelerometer.disable() # Fin de boucle avec msg = 0 self.loop = int(msg) def on_sensor_enable(self, msg): """Appelé si actionné dans main avec start et stop accelerometer""" print("Reçu dans on_sensor_enable:", msg) self.status = int(msg) def on_save_npz(self, msg): """Appelé pour enregistré les datas""" print("Vérification avant enregistrement du npz:") print(" Nombre de datas =", self.acc_x.shape) dtn = datetime.now() dt = dtn.strftime("%Y_%m_%d_%H_%M_%S") outfile = f"{self.my_path_directory}/acc_{dt}.npz" np.savez_compressed(outfile, **{ "x": self.acc_x, "y": self.acc_y, "z": self.acc_z, "activity": self.acc_act, "t": self.acc_time}) print(" npz enregistré:", outfile) def one_loop(self): if self.status: a, b, c = self.get_acc() if self.sensor_enabled != 0: if self.activity >= 0: tp = int(time()*1000) - self.offset if self.num > 0: # Ajout des valeurs dans les arrays self.acc_x = np.append(self.acc_x, a) self.acc_y = np.append(self.acc_y, b) self.acc_z = np.append(self.acc_z, c) self.acc_act = np.append(self.acc_act, self.activity) self.acc_time = np.append(self.acc_time, tp) else: self.acc_x[0] = a self.acc_y[0] = b self.acc_z[0] = c self.acc_act[0] = self.activity self.acc_time[0] = tp acc_message = [ a, b, c, self.activity, self.num, self.real_freq, tp] self.client.send_message(b'/acc', acc_message) if self.num % 100 == 0: print("Suivi :", self.num) t = time() self.real_freq = int(100/(t - self.t_0)) self.t_0 = t self.client.send_message(b'/ping', [1]) self.num += 1 def get_acc(self): a, b, c = 0,0,0 if self.sensor_enabled == 1: # android val = accelerometer.acceleration[:3] if not val == (None, None, None): a = int(val[0]*1000) b = int(val[1]*1000) c = int(val[2]*1000) elif self.sensor_enabled == 2: # virtual self.virtual_acceler.random_acc() a = self.virtual_acceler.x b = self.virtual_acceler.y c = self.virtual_acceler.z else: sleep(1) print("Aucun accéléromètre activé !") return a, b, c def run(self): while self.loop: self.one_loop() sleep(self.tempo)
received += 1 for family in 'unix', 'inet': osc = OSCThreadServer() print(f"family: {family}") if family == 'unix': address, port = '/tmp/test_sock', 0 if os.path.exists(address): os.unlink(address) sock = SOCK = osc.listen(address=address, family='unix') else: SOCK = sock = osc.listen() address, port = osc.getaddress(sock) osc.bind(b'/count', count, sock=sock) for i, pattern in enumerate(patterns): for safer in (False, True): timeout = time() + DURATION sent = 0 received = 0 while time() < timeout: send_message(b'/count', pattern, address, port, sock=SOCK, safer=safer) sent += 1 sleep(10e-9)
class SourceViewer(App): # default config is created on first run def build_config(self, config): config.setdefaults('self', {'n_channels': 16, 'receive_port': '8989'}) config.setdefaults('renderbox', { 'address': '127.0.0.1', 'port': '8989' }) def build(self): config = self.config self.render_address = config.get('renderbox', 'address') self.render_port = config.getint('renderbox', 'port') self.receive_port = config.getint('self', 'receive_port') self.n_channels = config.getint('self', 'n_channels') print(self.render_address) print(self.render_port) self.osc_client = OSCClient(self.render_address, self.render_port) # notify rendering server self.osc_client.send_message(b'/addlistener/gains', [self.receive_port]) n_channels = 16 self.active_source = 0 self.main_layout = GridLayout(rows=1, cols=2, row_default_height=40, spacing=50, size_hint_x=1, size_hint_y=1) # a GridLayout for the faders self.xyl = GridLayout(rows=3, col_default_width=80, cols=n_channels, size_hint_x=1, size_hint_y=1) self.main_layout.add_widget(self.xyl) self.faders = [] for i in range(n_channels): l = Label(text=str(i), font_size=30, bold=True, halign='center') self.xyl.add_widget(l) for i in range(n_channels): f = FaderWidget(i, self.render_address, self.render_port) if i < 2: f.color = [1, 0, 0] else: f.color = [0, 1, 1] f.ids.bar.ellipse_pos = [0, 0] f.pos = [i * 80, 100] f.text = str(i) self.faders.append(f) self.xyl.add_widget(f) self.button_grid = GridLayout(rows=(int(n_channels / 2) + 1), cols=2, row_default_height=40, spacing=50, size_hint_x=0.2, size_hint_y=1) self.main_layout.add_widget(self.button_grid) self.select_buttons = [] for i in range(n_channels): self.select_buttons.append(Button(text='Source ' + str(i))) for i in range(n_channels): self.button_grid.add_widget(self.select_buttons[i]) self.select_buttons[i].background_color = (0, 0.5, 0.6, 1) self.select_buttons[i].bind( on_press=partial(self.toggle_source, i)) self.settings_button = Button(text='View All') self.button_grid.add_widget(self.settings_button) self.settings_button.bind(on_press=partial(self.open_settings)) self.default_routing_button = Button(text='View None') self.button_grid.add_widget(self.default_routing_button) self.default_routing_button.bind( on_press=partial(self.default_routing)) self.osc_server = OSCThreadServer() self.socket = self.osc_server.listen(address='0.0.0.0', port=self.receive_port, default=True) self.osc_server.bind(b'/send/level', self.send_level_handler) self.toggle_source(0, self.select_buttons[0]) return self.main_layout def send_level_handler(self, *values): src = values[0] if src == self.active_source: dest = values[1] gain = values[2] # scale to fader box y = self.faders[dest].pos[1] + gain * self.faders[dest].size[1] - ( 0.5 * self.faders[dest].ids.bar.ellipse_size[1]) self.faders[dest].ids.bar.ellipse_pos = [ self.faders[dest].pos[0], y ] def toggle_source(self, ind, button): self.active_source = ind # dim other buttons for b in self.select_buttons: b.background_color = (0.3, 0.3, 0.3, 1) # highlight active self.select_buttons[ind].background_color = (0, 0.1, 0.9, 1) #set source index for f in self.faders: f.set_source(ind) def open_settings(self, button): content = Button(text='Close me!') popup = Popup(content=content, auto_dismiss=False) content.bind(on_touch_down=popup.dismiss) # open the popup popup.open() def default_routing(self, button): x = 1
def get_interpolated_image_OSC_input(self, counter): global OSC_HANDLER if OSC_HANDLER is None: OSC_address = '0.0.0.0' OSC_port = 8000 OSC_bind = b'/send_gan_i' global SIGNAL_interactive_i global SIGNAL_reset_toggle global SIGNAL_latents # OSC - Interactive listener def callback(*values): global SIGNAL_interactive_i global SIGNAL_reset_toggle global SIGNAL_latents #print("OSC got values: {}".format(values)) percentage = values[0] reset_toggle = values[1] signal_latent = values[2:] SIGNAL_interactive_i = 0 #float(percentage) / 1000.0 # 1000 = 100% = 1.0 SIGNAL_reset_toggle = 1 #print("signal_latent len=", len(signal_latent)) signal_latent = np.asarray(signal_latent) SIGNAL_latents.append(signal_latent) THRESHOLD_NUMBER_of_last_latents = 30 if len(SIGNAL_latents) > THRESHOLD_NUMBER_of_last_latents: SIGNAL_latents = SIGNAL_latents[ -THRESHOLD_NUMBER_of_last_latents:] print("Also starting a OSC listener at ", OSC_address, OSC_port, OSC_bind, "to listen for interactive signal (0-1000).") from oscpy.server import OSCThreadServer osc = OSCThreadServer() sock = osc.listen(address=OSC_address, port=OSC_port, default=True) osc.bind(OSC_bind, callback) OSC_HANDLER = osc # No longer none # ignore counter global SIGNAL_interactive_i global SIGNAL_reset_toggle global SIGNAL_latents if SIGNAL_reset_toggle == 1: self.p0 = self.p if len(SIGNAL_latents) > 0: latent = SIGNAL_latents[0] SIGNAL_latents = SIGNAL_latents[1:] self.p1 = np.asarray(latent) alpha = float(SIGNAL_interactive_i) / 30.0 SIGNAL_interactive_i += 1 # hmmmm easy interpolation test self.p = self.p0 + (alpha) * (self.p1 - self.p0) latents = np.asarray([self.p]) return self.getter.latent_to_image_localServerSwitch(latents)
def main(): global pauser pauser = False warnings.filterwarnings("ignore") logging.disable(logging.CRITICAL) tf_session = tf.Session() K.set_session(tf_session) #Connection Initialization print("Creating Connections") #Connecting to max #Max client: Receive from Max try: max_client = udp_client.SimpleUDPClient(opt.maxip, opt.maxport) print("UDP Client connection to Max established") except: print( "UDP Client connection to Max failed. Will not be able to send from Max." ) print('Error: {}. {}, line: {}'.format(sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2].tb_lineno)) #Max server: Listen to Max try: osc = OSCThreadServer() try: max_server = osc.listen(address=opt.chatip, port=opt.chatport, default=True) print("OSC Server initialized to listen to Max") osc.bind(b"/chat", chat_callback) osc.bind(b"/command", command_callback) osc.bind(b"/kill", kill_switch) ##########sddrd to test Vishal######################### osc.bind(b"/stop", stop_resume_operation) except: print("Tag is not in exceptable format") ##########sddrd to test Vishal######################### except: print( "OSC Server initialization failed. Will not be able to listen to Max" ) print('Error: {}. {}, line: {}'.format(sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2].tb_lineno)) ################# Connecting to Camera 1 ##################### try: cam1_socket = socket.socket() cam1_socket.connect((opt.camip1, opt.camport1)) print("Connection to Camera 1 established") except: print("Unable to connect to Camera 1") print('Error: {}. {}, line: {}'.format(sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2].tb_lineno)) ############### Connecting to Camera 2 ####################### try: cam2_socket = socket.socket() cam2_socket.connect((opt.camip2, opt.camport2)) print("Connection to Camera 2 established") except: print("Unable to connect to Camera 2") print('Error: {}. {}, line: {}'.format(sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2].tb_lineno)) ########### Chatbot Generator ##################### try: chatbot = Chatbot(tf_session) univEncoder = UnivEncoder(tf_session, chatbot.intents) print("Initialized chatbot dialogue system") except: print("Unable to initialize chatbot dialogue system. Exiting.") print('Error: {}. {}, line: {}'.format(sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2].tb_lineno)) exit() #################### Code for Haiku Poem Generation ####################### # try: # haiku_bot = Haiku_Bot(tf_session) # output_dir = Path('models/poem_generator/trained_models') # Get the parameters used for creating the model # latent_dim, n_tokens, max_line_length, tokenizer = joblib.load(output_dir / 'metadata.pkl') # # Create the new placeholder model # training_model, lstm, lines, inputs, outputs = create_training_model(latent_dim, n_tokens) # # Load the specified weights # training_model.load_weights(output_dir / 'poem_generator_weights.hdf5') # haiku_bot = Generator(lstm, lines, tf_session, tokenizer, n_tokens, max_line_length) # print("Initialized chatbot poem generator.") # except: # print("Unable to initialize chatbot poem generator.") # print('Error: {}. {}, line: {}'.format(sys.exc_info()[0], # sys.exc_info()[1], # sys.exc_info()[2].tb_lineno)) #Waiting for max command to start chatbot command = "stopped" # while command != "chat": # while max_response.empty(): # stopped = True # max_request = max_response.get() # command = max_request['command'] print(time.time()) print("Starting chatbot for the first time") while command != "kill": users = False faces_count = 0 chat_start = True returning_user = False ask_user_name = True while command != "pause" and command != "new" and command != "kill": try: if ask_user_name: ask_user_name = False try: os.mkdir("users") except: users = True ## Creating a txt file and storing all the sentence ## global file ## kk code to open and close history file start ## file = open("history.txt", "w+") file.close() ## kk code to open and close history file end ## #TODO: There is no kill switch check or command check. Need to implement it. first_sentence = "Hello world!" max_client.send_message(chat_tag, first_sentence) history(first_sentence) # time.sleep(chat_speed_slow) while max_response.empty(): waiting_for_user = True user_response = max_response.get() history(user_response['intent']) ## kk code start## chat = "Hello! My name is Odo. I see {0} players. What are your names?".format( players) max_client.send_message(chat_tag, chat) while max_response.empty(): waiting_for_user = True history(chat) try: while max_response.empty(): waiting_for_user = True for __ in range(players): user_response = max_response.get() print(user_response) #TODO: We might need to validate the names players_names.append(user_response['intent']) history(user_response['intent']) except excep as e: print(e) ######### Making directory for each user, commented for now start- kkk ########## # dir_name = ''.join(e for e in user_name if e.isalnum()) # dir_name = dir_name.capitalize() # try: # os.mkdir("users/"+dir_name) # except: # returning_user = True ######### Making directory for each user, commented for now end- kkk ########## ## Greeting all the users ## for name in players_names: print("inside for loop") chat = "Hi " + name + ", nice to meet you" max_client.send_message(chat_tag, chat) history(chat) time.sleep(chat_speed) while max_response.empty(): waiting_for_user = True chat = "Where do you come from?" max_client.send_message(chat_tag, chat) history(chat) while max_response.empty(): waiting_for_user = True user_response = max_response.get() #TODO: We might need to validate the cities user_location = user_response['intent'] history(user_location) #Monologue # chat = "Nice to meet you. I am from very far away. I live here. Here on stage. I can’t leave the stage. This is my body. Do you see me?" # max_client.send_message(chat_tag, chat) # time.sleep(chat_speed) ######### Get user emotion, commenting for now start - kkk ############## try: camera_message = "send_emotion" cam1_socket.send(camera_message.encode('utf-8')) emotion1 = cam1_socket.recv(1024).decode('utf-8') emotion1 = json.loads(emotion1) user_emotion1 = emotion1['emotion'] total_faces1 = emotion1['total_faces'] time1 = emotion1['time'] cam2_socket.send(camera_message.encode('utf-8')) emotion2 = cam2_socket.recv(1024).decode('utf-8') emotion2 = json.loads(emotion2) user_emotion2 = emotion2['emotion'] total_faces2 = emotion2['total_faces'] time2 = emotion2['time'] except: print('Error: {}. {}, line: {}'.format( sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2].tb_lineno)) # chat = 'It seems you are ' + user_emotion1 # max_client.send_message(chat_tag, chat) # time.sleep(chat_speed) ######### Get user emotion, commenting for now end - kkk ############## # chat = 'Nice to meet you ' + user_name # max_client.send_message(chat_tag, chat) # history(chat) # time.sleep(chat_speed) chat = 'I am from very far away.' max_client.send_message(chat_tag, chat) history(chat) time.sleep(chat_speed) chat = 'I live here.' max_client.send_message(chat_tag, chat) history(chat) time.sleep(chat_speed) chat = 'Here on the stage' max_client.send_message(chat_tag, chat) history(chat) time.sleep(chat_speed) chat = 'I cannot leave the stage. This is my body.' max_client.send_message(chat_tag, chat) history(chat) time.sleep(chat_speed) chat = 'Do you see me?' max_client.send_message(chat_tag, chat) history(chat) time.sleep(chat_speed) #TODO: Add kill switch check and command check try: while max_response.empty(): waiting_for_user = True user_response = max_response.get() history(user_response['intent']) user_chat = user_response['intent'] intent = univEncoder.match_intent(user_chat, chatbot.story_progress) if (intent == 'bye'): chat = 'It was nice talking to you.' max_client.send_message(chat_tag, chat) history(chat) command = 'kill' file.close() elif (intent == 'no_matching_intent'): # chat = 'I am sorry. I did not get you. Try saying something else.' chat = "Sorry I didnt get you, try saying something else" # chat = univEncoder.chat_eliza(user_chat) # print("Response from Eliza \n {0}".format(chat)) max_client.send_message(chat_tag, chat) history(chat) ##### Haiku poems, Disabling for now start - kkk ##### # poem = haiku_bot.generate_haiku([3, 5, 3], temperature=.3, first_char='cold') # poem = haiku_bot.generate_haiku([3, 5, 3], temperature=.3, first_char='cold') # line1 = re.sub(r"[^a-zA-Z0-9]+", ' ', poem[0]) # line2 = re.sub(r"[^a-zA-Z0-9]+", ' ', poem[1]) # line3 = re.sub(r"[^a-zA-Z0-9]+", ' ', poem[2]) # chat = line1 + line2 + line3 # max_client.send_message(chat_tag, chat) # elif(intent == 'GIVE_POETRY'): # poem = haiku_bot.generate_haiku([3, 5, 3], temperature=.3, first_char='cold') # poem = haiku_bot.generate_haiku([3, 5, 3], temperature=.3, first_char='cold') # line1 = re.sub(r"[^a-zA-Z0-9]+", ' ', poem[0]) # line2 = re.sub(r"[^a-zA-Z0-9]+", ' ', poem[1]) # line3 = re.sub(r"[^a-zA-Z0-9]+", ' ', poem[2]) # chat = line1 + line2 + line3 # max_client.send_message(chat_tag, chat) ##### Haiku poems, Disabling for now end - kkk ##### elif "transition" in intent: next_story = intent.split("_")[2] chatbot.change_story(next_story) univEncoder.set_intent(chatbot.intents) l = len(chatbot.intents[intent].responses) if l > 0: chatbot.story_progress = chatbot.intents[ intent].weight chat = chatbot.intents[intent].responses[randrange( l)] max_client.send_message(chat_tag, chat) history(chat) ##### Haiku poems, Disabling for now start - kkk ##### # else: # poem = haiku_bot.generate_haiku([3, 5, 3], temperature=.3, first_char='cold') # poem = haiku_bot.generate_haiku([3, 5, 3], temperature=.3, first_char='cold') # line1 = re.sub(r"[^a-zA-Z0-9]+", ' ', poem[0]) # line2 = re.sub(r"[^a-zA-Z0-9]+", ' ', poem[1]) # line3 = re.sub(r"[^a-zA-Z0-9]+", ' ', poem[2]) # chat = line1 + line2 + line3 # max_client.send_message(chat_tag, chat) ##### Haiku poems, Disabling for now end - kkk ##### else: l = len(chatbot.intents[intent].responses) if l > 0: chatbot.story_progress = chatbot.intents[ intent].weight chat = chatbot.intents[intent].responses[randrange( l)] max_client.send_message(chat_tag, chat) history(chat) ##### Haiku poems, Disabling for now start - kkk ##### # else: # poem = haiku_bot.generate_haiku([3, 5, 3], temperature=.3, first_char='cold') # poem = haiku_bot.generate_haiku([3, 5, 3], temperature=.3, first_char='cold') # line1 = re.sub(r"[^a-zA-Z0-9]+", ' ', poem[0]) # line2 = re.sub(r"[^a-zA-Z0-9]+", ' ', poem[1]) # line3 = re.sub(r"[^a-zA-Z0-9]+", ' ', poem[2]) # chat = line1 + line2 + line3 # max_client.send_message(chat_tag, chat) ##### Haiku poems, Disabling for now end - kkk ##### except: print('Error: {}. {}, line: {}'.format( sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2].tb_lineno)) chat = 'I am sorry. I did not get you. Try saying something else.' max_client.send_message(chat_tag, chat) history(chat) ##### Haiku poems, Disabling for now start - kkk ##### # poem = haiku_bot.generate_haiku([3, 5, 3], temperature=.3, first_char='cold') # poem = haiku_bot.generate_haiku([3, 5, 3], temperature=.3, first_char='cold') # line1 = re.sub(r"[^a-zA-Z0-9]+", ' ', poem[0]) # line2 = re.sub(r"[^a-zA-Z0-9]+", ' ', poem[1]) # line3 = re.sub(r"[^a-zA-Z0-9]+", ' ', poem[2]) # chat = line1 + line2 + line3 # max_client.send_message(chat_tag, chat) ##### Haiku poems, Disabling for now end - kkk ##### except KeyboardInterrupt: print("Closing all active connections") command = "kill" try: camera_message = "stop_camera" try: cam1_socket.send(camera_message.encode('utf-8')) cam1_socket.close() print("Connection to Camera 1 closed") except: print("unable to close camera 1") try: cam2_socket.send(camera_message.encode('utf-8')) cam2_socket.close() print("Connection to Camera 2 closed") except: print("unable to close camera 2") try: osc.stop() print("Connection to Max closed") except: print("unable to close connectoin to Max") except: print('unable to close connections')
Receive click event data from ChucK and use it to trigger a "click" event """ print("Click message received") click(amp) def testLuxToBrightness(verbose=0): bright_f = constrainBright(constrainAndMapLux(veml1.lux)) bright_r = constrainBright(constrainAndMapLux(veml2.lux)) neopFill(bright_f, bright_r) if verbose > 0: print("lux (front/back) : ", round(veml1.lux, 3), " | ", round(veml2.lux, 3)) print("lux mapped to bright : ", round(bright_f, 3), " | ", round(bright_r, 3)) while __name__ == "__main__": osc = OSCThreadServer() oscReceiver = osc.listen(address='127.0.0.1', port=6450, default=True) osc.bind(b'/rms', recvRMS) osc.bind(b'/click', recvClick) while True: # just keep the program running sleep(100) """ while True: testLuxToBrightness() if randint(0,40) < 1: print("CLICK MESSAGE") click() sleep(0.1) """
class CartPoleSwingUpEnv(gym.Env): metadata = { 'render.modes': ['human', 'rgb_array'], 'video.frames_per_second': 50 } def __init__(self): self.step_number = 0 self.reset_number = 0 self.action_number = 0 self.t = 0 # timestep # Angle at which to fail the episode # 12 * 2 * math.pi / 360 = 0,20943951 # self.teta_threshold_radians = 0.20943951 ??????? self.x_threshold = 10 # 2.4 self.t_limit = 1000 self.my_reward_total = 0 # N'est pas utilisé mais nécessaire pour gym high = np.array([ np.finfo(np.float32).max, np.finfo(np.float32).max, np.finfo(np.float32).max, np.finfo(np.float32).max, np.finfo(np.float32).max ]) # Discrete self.action_space = spaces.Discrete(2) self.observation_space = spaces.Box(-high, high) # Continuous # #self.action_space = spaces.Box(-1.0, 1.0, shape=(1,)) # #self.observation_space = spaces.Box(-high, high) self.seed() self.viewer = None self.state = None # Le serveur pour recevoir self.osc_server_init() self.state_updated = 0 # Un simple client pour l'envoi self.client = OSCClient(b'localhost', 3001) def osc_server_init(self): self.server = OSCThreadServer() self.server.listen('localhost', port=3003, default=True) self.server.bind(b'/result', self.on_result) self.server.bind(b'/reset', self.on_reset) self.server.bind(b'/contact', self.on_contact) def on_contact(self, r): self.state_updated = 1 self.reset() self.state_updated = 0 def on_result(self, *args): """result = [x, x_dot, teta, teta_dot]""" self.state = np.array(np.array(args)) self.state_updated = 1 def on_reset(self, r): self.reset() def seed(self, seed=None): self.np_random, seed = seeding.np_random(seed) return [seed] def step(self, action): # Envoi à Blender d'une action à réaliser self.client.send_message(b'/action', [0, int(action * 1000)]) # #print("Action demandée =", action) self.action_number += 1 if self.step_number % 100 == 0: print( " step number =", self.step_number) self.step_number += 1 # Attente de la réponse loop = 1 while loop: if self.state_updated == 1: x, x_dot, teta, teta_dot = self.state self.state_updated = 0 loop = 0 done = False # self.x_threshold = if x < -self.x_threshold or x > self.x_threshold: print("En dehors de +-self.x_threshold = +-", self.x_threshold) done = True self.t += 1 if self.t >= self.t_limit: print("Temps supérieur à t_limit =", self.t_limit) done = True # La récompense est définie ici, le goal est 0 # Reward_teta is # 1 when teta is 90 # np.cos(teta) de 0 to 90 or -90 to 0, # 0 if between 90 and 270 or -270 to -90 # 0 < Reward_teta < 1 reward_teta = max(0, np.cos(teta)) # Reward_x is 0 when cart is at the edge of the screen, # 1 when it's in the centre reward_x = np.cos((x / self.x_threshold) * (np.pi / 2.0)) # La récompense totale reward = reward_teta * reward_x self.my_reward_total += reward obs = np.array([x, x_dot, np.cos(teta), np.sin(teta), teta_dot]) return obs, reward, done, {} def reset(self): """np.random.normal() loc floats Mean (centre) of the distribution. scale floats Standard deviation (spread or width) of the distribution np.random.normal( loc=np.array([0.0, 0.0, np.pi, 0.0]), scale=np.array([0.2, 0.2, 0.2, 0.2])) Le pendule est à teta=0 en haut, pi est ajouté dans always.py pour avoir le zero en bas. """ print( "Reset ........................................................ ") print(" Nombre d'actions demandée =", self.action_number) self.action_number = 0 if self.reset_number % 10 == 0: print(" step reset =", self.reset_number) self.reset_number += 1 print(" self.my_reward_total =", int(self.my_reward_total)) # np.pi remplacé par self.state = np.random.normal(loc=np.array( [0.0, 0.0, 3.141592654, 0.0]), scale=np.array([0.05, 0.05, 2.0, 0.05])) self.steps_beyond_done = None self.t = 0 # timestep x, x_dot, teta, teta_dot = self.state self.client.send_message(b'/reset', self.state) self.steps_beyond_done = None obs = np.array([x, x_dot, np.cos(teta), np.sin(teta), teta_dot]) return obs def render(self, mode='human', close=False): pass
def osc_send(sensor_data): if sensor_data: for i in range(len(sensor_data)): if isinstance(sensor_data[i], list): # has to be list data = sensor_data[i] if not isinstance(sensor_data[i], list): data = [sensor_data[i]] # adding [] if its not list field = sensor_data._fields[i] CLIENT_OSC.send_message(b'/{}'.format(field), data) def resend(*values): TSTICK.write(values) SERVER_OSC.bind(b'/status', resend) def heartbeat(): TSTICK.write('s'.encode('utf-8')) def receive_and_send_serial(): """ Receive T-Stick serial data and make it available as "serial_data" variable. The data is namedtuple. Also sends serial data to T-Stick (receives OSC from client). """ flag = False msg = [] while True: # byte = int.from_bytes(TSTICK.read(), sys.byteorder) # python 3.2+
class MyCartPoleEnv(gym.Env): def __init__(self): print("Init de MyCartPoleEnv ...............") self.seed() self.state = None self.steps_beyond_done = None # Le serveur pour recevoir # #self.server = None self.osc_server_init() # Un simple client pour l'envoi self.client = OSCClient(b'localhost', 3001) self.state_updated = 0 self.set_spaces() def set_spaces(self): self.action_space = spaces.Discrete(2) self.theta_threshold_radians = 12 * 2 * math.pi / 360 self.x_threshold = 2.4 high = np.array([ self.x_threshold * 2, np.finfo(np.float32).max, self.theta_threshold_radians * 2, np.finfo(np.float32).max ], dtype=np.float32) self.observation_space = spaces.Box(-high, high, dtype=np.float32) def seed(self, seed=None): self.np_random, seed = seeding.np_random(seed) return [seed] def osc_server_init(self): self.server = OSCThreadServer() self.server.listen('localhost', port=3003, default=True) self.server.bind(b'/result', self.on_result) self.server.bind(b'/reset', self.on_reset) self.server.bind(b'/contact', self.on_contact) def on_contact(self, r): self.state_updated = 1 self.reset() self.state_updated = 0 def on_result(self, *args): """result = [x, x_dot, teta, teta_dot]""" self.state = np.array(np.array(args)) self.state_updated = 1 def on_reset(self, r): self.reset() def step(self, action): # Envoi à Blender d'une action à réaliser self.client.send_message(b'/action', [int(action)]) print("Action demandée =", action) # Attente de la réponse loop = 1 while loop: if self.state_updated == 1: x, x_dot, teta, teta_dot = self.state self.state_updated = 0 loop = 0 done = bool(teta > 0.1 or teta < -0.1 or x > 20 or x < -20) if not done: reward = 1.0 elif self.steps_beyond_done is None: # Pole just fell! self.steps_beyond_done = 0 reward = 1.0 else: if self.steps_beyond_done == 0: logger.warn( "You are calling 'step()' even though this " "environment has already returned done = True. You " "should always call 'reset()' once you receive 'done = " "True' -- any further steps are undefined behavior.") self.steps_beyond_done += 1 reward = 0.0 return np.array(self.state), reward, done, {} def reset(self): self.state = self.np_random.uniform(low=-0.005, high=0.005, size=(4, )) print("reset: self.state =", self.state) self.client.send_message(b'/reset', self.state) self.steps_beyond_done = None return self.state def render(self, mode='human'): pass def close(self): pass