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
