def update_robot(self, unused_addr, args):
print("update robot")
self.robot.run()
score = Robot.count("Soja")
self.playerListBox.delete(0, tk.END)
#self.playerListBox.insert(tk.END, player_name + " " + str(score))
print(self.players_list)
for p in self.players_list:
self.playerListBox.insert(tk.END,
p + " " + str(self.players_list[p]))
msg = osc_message_builder.OscMessageBuilder(address="/player")
msg.add_arg(player_name)
msg.add_arg(score) #
msg = msg.build()
self.to_client_client.send(msg)
if self.robot.win:
# I am the winner
# lets tel that to ohters
msg = osc_message_builder.OscMessageBuilder(address="/winner")
msg.add_arg(player_name)
msg.add_arg(score)
msg = msg.build()
#self.to_client_client.send(msg)
self.to_server_client.send(msg)
alert(text="Vous avez gagné la partie !")
def send(predict=0):
if osc_type == "n":
print("predict + no osc", predict)
return
elif osc_type == "r":
print("predict + send predict osc", predict)
msg = osc_message_builder.OscMessageBuilder(address="/predict")
msg.add_arg(predict)
msg = msg.build()
client.send(msg)
elif osc_type == "t": # Train
msg = osc_message_builder.OscMessageBuilder(address="/key_send")
print("Send : ", config.console_input_number)
msg.add_arg(int(config.console_input_number))
msg = msg.build()
client.send(msg)
elif osc_type == "f":
command = face2data.detect_face_state(predict)
if command is None:
#print("command is not setted")
return
msg = {}
builded_msg = {}
addresses = {"/predict": predict, "/command": command}
#print(addresses)
for a in addresses.items():
msg[a[0]] = osc_message_builder.OscMessageBuilder(address=a[0])
#print(a[1])
msg[a[0]].add_arg(str(a[1]))
builded_msg[a[0]] = msg[a[0]].build()
client.send(builded_msg[a[0]])
def run(self):
logger.info("Running Data Distibuter OSC")
print("sending osc")
while True:
datum = self.data_queue.get(block=True)
#print("sending osc")
msg = osc_message_builder.OscMessageBuilder(address="/data")
o_data = datum['orientation_sensor']
quaternion = [o_data['w'], o_data['x'], o_data['y'], o_data['z']]
x, y, z = euler_from_quaternion(quaternion)
ax, ay, az = o_data['ax'], o_data['ay'], o_data['az']
msg.add_arg(x)
msg.add_arg(y)
msg.add_arg(z)
msg.add_arg(ax)
msg.add_arg(ay)
msg.add_arg(az)
msg = msg.build()
self.osc_client.send(msg)
#self.osc_client_susi.send(msg)
msg = osc_message_builder.OscMessageBuilder(address="/calibrated")
o_data = datum['orientation_sensor']
msg.add_arg(o_data["calibrated"])
msg = msg.build()
self.osc_client.send(msg)
#self.osc_client_susi.send(msg)
if self.data_queue.qsize() > 10:
logger.warning("Data Queue size increasing")
def play(self): # doesn't work yet
if self.renderer is 0:
pass #TO DO
if self.renderer is 1:
N = len(self.ID)
sampleoffset = [
] # offset between start of movements of different sources with respect
sampleoffset[0] = 0 # to first source in ID list
for i in range(1, N):
sampleoffset[i] = t[i][0] - t[0][0]
diffToJack = [
] # desired sample difference between jack clock and samples in file
diffToJack[0] = self.jclient.transport_frame - t[0][0]
for i in range(1, N):
diffToJack[i] = diffToJack[0] - sampleoffset[i]
sampleoffset = []
#iterate through sources that should be played
for i in range(0, len(self.sources_to_play)):
if sources_to_play[i] is 0:
pass
if len(sampleoffset) is 0:
sampleoffset
else:
t_ix = 0
msg = omb.OscMessageBuilder(address="/source/position")
msg.add_arg(self.sources_to_play[i])
msg.add_arg(self.x[i][t_ix])
msg.add_arg(self.y[i][t_ix])
msg = msg.build()
self.sendOSC(msg)
while 1:
for i in range(0, len(self.sources_to_play)):
if sources_to_play[i] is 0:
pass
else:
pass
print('loop i=' + str(i))
print(self.t[i])
print(jackPos)
print(np.abs(self.t[i] - jackPos))
tmpIdx = np.argmin(np.abs(self.t[i] - jackPos)) ##??
print(tmpIdx)
msg = omb.OscMessageBuilder(address="/source/position")
msg.add_arg(self.ID[i])
msg.add_arg(self.x[i][tmpIdx] * 5) #why *5??
msg.add_arg(self.y[i][tmpIdx] * -5)
msg = msg.build()
self.sendOSC(msg)
last_jackPos = jackPos
ime.sleep(0.02)
def inner1(*args, **kwargs):
record_msg = osc_message_builder.OscMessageBuilder(address='/record')
record_msg.add_arg(1, arg_type='i')
record_msg = record_msg.build()
client.send(record_msg)
function(*args, **kwargs)
time.sleep(1)
record_msg = osc_message_builder.OscMessageBuilder(address='/record')
record_msg.add_arg(0, arg_type='i')
record_msg = record_msg.build()
client.send(record_msg)
def connect(self):
if self.renderer is 0:
pass
if self.renderer is 1:
#subscribe to SSR (SSR needs to be SERVER)
msg1 = omb.OscMessageBuilder(address="/subscribe")
msg1.add_arg(True, "T")
msg1 = msg1.build()
self.sendOSC(msg1)
# change message level of this script to server
msg2 = omb.OscMessageBuilder(address="/message_level")
msg2.add_arg(3, "i")
msg2 = msg2.build()
self.sendOSC(msg2)
def sendInitMessage(self):
try:
msg = osc_message_builder.OscMessageBuilder(address="/text")
msg.add_arg('タイムラインが流れます')
msg = msg.build()
msg2 = osc_message_builder.OscMessageBuilder(address="/created_at")
msg2.add_arg('Today')
msg2 = msg2.build()
self.client.send(msg)
self.client.send(msg2)
except:
print('ParserError')
def sendMessage(self, text='', created_at=''):
try:
msg = osc_message_builder.OscMessageBuilder(address="/text")
msg.add_arg(text)
msg = msg.build()
msg2 = osc_message_builder.OscMessageBuilder(address="/created_at")
msg2.add_arg(created_at)
msg2 = msg2.build()
self.client.send(msg)
self.client.send(msg2)
except:
print('ParserError')
def sendMessage(self, module_path, command_name, *args, **kwargs):
module_path = "/{0}".format(module_path.replace(".", "/"))
osc_bundle = osc_bundle_builder.OscBundleBuilder(
osc_bundle_builder.IMMEDIATELY)
for key, value in kwargs.items():
msg = osc_message_builder.OscMessageBuilder(
address="{0}/attributes/{1}".format(module_path, key))
msg.add_arg(value)
osc_bundle.add_content(msg.build())
msg = osc_message_builder.OscMessageBuilder(
address="{0}/{1}".format(module_path, "operation"))
msg.add_arg(command_name)
osc_bundle.add_content(msg.build())
osc_bundle = osc_bundle.build()
self._client.send(osc_bundle)
def sendOSC_coords(self, coords, force):
msgStructX = osc_message_builder.OscMessageBuilder(address='/coords/x')
msgStructY = osc_message_builder.OscMessageBuilder(address='/coords/y')
msgStructForce = osc_message_builder.OscMessageBuilder(address='/coords/force')
for m in coords:
msgStructX.add_arg(m[1])
msgStructY.add_arg(m[0])
for f in force:
msgStructForce.add_arg(f)
msgStructX = msgStructX.build()
msgStructY = msgStructY.build()
msgStructForce = msgStructForce.build()
self.client.send(msgStructX)
self.client.send(msgStructY)
self.client.send(msgStructForce)
def test_long_list(self):
huge_list = list(range(512))
builder = osc_message_builder.OscMessageBuilder(address="/SYNC")
builder.add_arg(huge_list)
msg = builder.build()
print(msg._dgram)
self.assertSequenceEqual([huge_list], msg.params)
def send_reading(client, adr, mode): # self, junk):
# we send the Pi's IP address as the OSC address
# so the host computer knows which Pi sent a message
packet = osc_message_builder.OscMessageBuilder(address=adr)
# adds whichPi to the OSC message
# hostname = socket.gethostname()
# print(hostname)
# for dev mode only
if mode == 'local':
pi = choice(["pione", "pitwo", "pithree", "pifour", "pifive", "pisix",
"piseven", "pieight"])
val = randrange(0, 100)
hostname = pi
packet.add_arg(hostname, arg_type='s')
# adds distance reading to the OSC message
packet.add_arg(val, arg_type='f')
# completes the OSC message
packet = packet.build()
# sends distance back to the host
client.send(packet)
print("sending:", adr, hostname, val)
def test_all_param_types(self):
builder = osc_message_builder.OscMessageBuilder(address="/SYNC")
builder.add_arg(4.0)
builder.add_arg(2)
builder.add_arg("value")
builder.add_arg(True)
builder.add_arg(False)
builder.add_arg(b"\x01\x02\x03")
builder.add_arg([1, ["abc"]])
# The same args but with explicit types.
builder.add_arg(4.0, builder.ARG_TYPE_FLOAT)
builder.add_arg(2, builder.ARG_TYPE_INT)
builder.add_arg("value", builder.ARG_TYPE_STRING)
builder.add_arg(True)
builder.add_arg(False)
builder.add_arg(b"\x01\x02\x03", builder.ARG_TYPE_BLOB)
builder.add_arg([1, ["abc"]],
[builder.ARG_TYPE_INT, [builder.ARG_TYPE_STRING]])
builder.add_arg(4278255360, builder.ARG_TYPE_RGBA)
self.assertEqual(len("fisTFb[i[s]]") * 2 + 1, len(builder.args))
self.assertEqual("/SYNC", builder.address)
builder.address = '/SEEK'
msg = builder.build()
self.assertEqual("/SEEK", msg.address)
self.assertSequenceEqual(
[4.0, 2, "value", True, False, b"\x01\x02\x03", [1, ["abc"]]] * 2 +
[4278255360], msg.params)
def build_message(msg_addr, msg_args):
"""Builds pythonsosc OSC message.
Parameters
----------
msg_addr : str
SuperCollider address.
msg_args : list
List of arguments to add to message.
Returns
-------
OscMessage
Message ready to be sent.
"""
if msg_args is None:
msg_args = []
if not msg_addr.startswith('/'):
msg_addr = '/' + msg_addr
builder = osc_message_builder.OscMessageBuilder(address=msg_addr)
if not hasattr(msg_args, '__iter__') or isinstance(msg_args, (str, bytes)):
msg_args = [msg_args]
for msg_arg in msg_args:
builder.add_arg(msg_arg)
msg = builder.build()
return msg
def send_message(address, message):
client = udp_client.UDPClient(server_ip, server_port)
# msg = osc_message_builder.OscMessageBuilder(address=address)
msg = osc_message_builder.OscMessageBuilder()
msg.address = address
msg.add_arg(message)
client.send(msg.build())
def run(self, edit):
self.settings = sublime.load_settings('Antescofo.sublime-settings')
address = self.settings.get('antescofoip', 'localhost')
port = self.settings.get('antescofoport', 5678)
# Walk through each region in the selection
for region in self.view.sel():
# If no region, then just send the line!
if region.empty():
# Expand the region to the full line it resides on, excluding the newline
line = self.view.line(region)
# Extract the string for the line, and add a newline
Contents = self.view.substr(line) + '\n'
else:
# if region, then send the region
# Get the selected text
Contents = self.view.substr(region) + '\n'
# Send OSC message
if pyosc:
## Send using pyosc
client = OSC.OSCClient()
client.connect((address, port))
oscmsg = OSC.OSCMessage('/antescofo/cmd')
oscmsg.append('playstring')
oscmsg.append(Contents)
client.send(oscmsg)
else:
client = udp_client.UDPClient(address, port)
oscmsg = osc_message_builder.OscMessageBuilder(
address="/antescofo/cmd")
oscmsg.add_arg("playstring")
oscmsg.add_arg(Contents)
oscmsg = oscmsg.build()
client.send(oscmsg)
def poweroff():
led.off()
print('power off')
omx1 = udp_client.UDPClient("192.168.1.201", 9998)
omx2 = udp_client.UDPClient("192.168.1.202", 9998)
omx3 = udp_client.UDPClient("192.168.1.203", 9998)
omx4 = udp_client.UDPClient("192.168.1.204", 9998)
omx5 = udp_client.UDPClient("192.168.1.205", 9998)
omx6 = udp_client.UDPClient("192.168.1.206", 9998)
omx7 = udp_client.UDPClient("192.168.1.207", 9998)
omx8 = udp_client.UDPClient("192.168.1.208", 9998)
omx9 = udp_client.UDPClient("192.168.1.209", 9998)
omx10 = udp_client.UDPClient("192.168.1.210", 9998)
omx11 = udp_client.UDPClient("192.168.1.211", 9998)
omx12 = udp_client.UDPClient("192.168.1.212", 9998)
msg = osc_message_builder.OscMessageBuilder(address="/omxplayer")
msg.add_arg(1)
msg.add_arg(4)
msg = msg.build()
omx1.send(msg)
omx2.send(msg)
omx3.send(msg)
omx4.send(msg)
omx5.send(msg)
omx6.send(msg)
omx7.send(msg)
omx8.send(msg)
omx9.send(msg)
omx10.send(msg)
omx11.send(msg)
omx12.send(msg)
def execute(self, context):
global _report
bcw = bpy.context.window_manager
#For sending
try:
self.client = udp_client.UDPClient(bcw.addosc_udp_out, bcw.addosc_port_out)
msg = osc_message_builder.OscMessageBuilder(address="/blender")
msg.add_arg("Hello from Blender, simple test.")
msg = msg.build()
self.client.send(msg)
except OSError as err:
_report[1] = err
return {'CANCELLED'}
#Setting up the dispatcher for receiving
try:
self.dispatcher = dispatcher.Dispatcher()
self.dispatcher.set_default_handler(OSC_callback)
self.server = osc_server.ThreadingOSCUDPServer((bcw.addosc_udp_in, bcw.addosc_port_in), self.dispatcher)
self.server_thread = threading.Thread(target=self.server.serve_forever)
self.server_thread.start()
except OSError as err:
_report[0] = err
return {'CANCELLED'}
#inititate the modal timer thread
context.window_manager.modal_handler_add(self)
self._timer = context.window_manager.event_timer_add(bcw.addosc_rate/1000, context.window)
context.window_manager.status = "Running"
return {'RUNNING_MODAL'}
def subscribe(self):
msg = omb.OscMessageBuilder(address="/subscribe")
msg.add_arg(True,"T")
msg.add_arg(self.ip)
msg.add_arg(self.receiveport)
msg=msg.build()
self.osc_client.send(msg)
def delete_source(self, i):
msg = omb.OscMessageBuilder(address="/source/delete")
msg.add_arg(i)
msg=msg.build()
self.osc_client.send(msg)
if i == self.max_sourceID:
self.max_sourceID = self.max_sourceID - 1 # will cause problems if a source with non-maximal ID will be deleted
def play_one(cursor):
messages = []
for (name, track) in state.tracks.items():
if track[cursor]:
mute = state.tracks_tmp_mute.get(name, 0)
if mute > 0:
state.tracks_tmp_mute[name] = mute - 1
continue
msg_builder = osc_message_builder.OscMessageBuilder(address=name)
for value in state.tracks_params[name]:
if callable(value):
value = value()
msg_builder.add_arg(
value, msg_builder.ARG_TYPE_FLOAT if type(value) == float
else msg_builder.ARG_TYPE_INT) # todo: improve this shit
messages.append(msg_builder.build())
if len(messages) > 0:
bundle_builder = osc_bundle_builder.OscBundleBuilder(
osc_bundle_builder.IMMEDIATELY)
for msg in messages:
bundle_builder.add_content(msg)
client.send(bundle_builder.build())
def test_bool_encoding(self):
builder = osc_message_builder.OscMessageBuilder('')
builder.add_arg(0)
builder.add_arg(1)
builder.add_arg(False)
builder.add_arg(True)
self.assertEqual(builder.args, [("i", 0), ("i", 1), ("F", False), ("T", True)])
def send_note(pitch, duration, amplitude, f1, f2, f3, f4, f5):
"""Send a note to Q.
Each of the parameters of the note are individually added as arguments
to an OSC message.
Arguments:
pitch (int)
duration (int)
amplitude (int)
f1 (int)
f2 (int)
f3 (int)
f4 (int)
f5 (int)
Returns:
None
"""
msg = osc_message_builder.OscMessageBuilder(address="/note")
msg.add_arg(pitch)
msg.add_arg(duration)
msg.add_arg(amplitude)
msg.add_arg(f1)
msg.add_arg(f2)
msg.add_arg(f3)
msg.add_arg(f4)
msg.add_arg(f5)
msg = msg.build()
output_client.send(msg)
def send_questions_to_line_editor():
"""
Sends data for display to Line Editor
"""
data = get_api_interact_data()['questions']
print("Called send question to the line editor")
#client = udp_client.UDPClient(ip_osc_editor, port_client_editor,1)
#builder = osc_message_builder.OscMessageBuilder(address='/textques')
#for k,v in data.items():
# builder.add_arg(v)
#builder.add_arg(.75)
#print('builder ', builder.address)
#client.send(builder.build())
#osc_dispatch('/textquest', .75, ip=ip_osc_server, port=port_client_editor)
# print("sent {0} to {1}:{2}".format(builder.args, ip_osc_editor, port_client_editor))
ip = ip_osc
port = port_client_editor
client = udp_client.UDPClient(ip, port, 1)
print("Send Data to Line Editor {}:{}", ip, port)
builder = osc_message_builder.OscMessageBuilder(address='/textques')
for k, v in data.items():
print(k, v)
builder.add_arg(v)
client.send(builder.build())
print("sent {0} to {1}:{2}".format(builder.args, ip, port))
broadcast_state()
return None
def oscaudio_send(addr, channel, cmd, data):
msg = osc_message_builder.OscMessageBuilder(addr)
msg.add_arg(channel)
msg.add_arg(cmd)
msg.add_arg(data)
msg = msg.build()
client.send(msg)
def reboot():
led.off()
omx1 = udp_client.UDPClient("192.168.1.201", 9998)
omx2 = udp_client.UDPClient("192.168.1.202", 9998)
omx3 = udp_client.UDPClient("192.168.1.203", 9998)
omx4 = udp_client.UDPClient("192.168.1.204", 9998)
omx5 = udp_client.UDPClient("192.168.1.205", 9998)
omx6 = udp_client.UDPClient("192.168.1.206", 9998)
omx7 = udp_client.UDPClient("192.168.1.207", 9998)
omx8 = udp_client.UDPClient("192.168.1.208", 9998)
omx9 = udp_client.UDPClient("192.168.1.209", 9998)
omx10 = udp_client.UDPClient("192.168.1.210", 9998)
omx11 = udp_client.UDPClient("192.168.1.211", 9998)
omx12 = udp_client.UDPClient("192.168.1.212", 9998)
msg2 = osc_message_builder.OscMessageBuilder(address="/omxplayer")
msg2.add_arg(1)
msg2.add_arg(3)
msg2 = msg2.build()
omx1.send(msg2)
omx2.send(msg2)
omx3.send(msg2)
omx4.send(msg2)
omx5.send(msg2)
omx6.send(msg2)
omx7.send(msg2)
omx8.send(msg2)
omx9.send(msg2)
omx10.send(msg2)
omx11.send(msg2)
omx12.send(msg2)
check_call(['sudo', 'reboot'])
def send_command(self, address, argument=''):
msg = osc_message_builder.OscMessageBuilder(address=address)
msg.add_arg('SONIC_PI_PYTHON')
if argument != "":
msg.add_arg(argument)
msg = msg.build()
self.client.send(msg)
def broadcast_color(red: int, green: int, blue: int):
""" Send out color """
msg = osc_message_builder.OscMessageBuilder(address='/color')
msg.add_arg(red)
msg.add_arg(green)
msg.add_arg(blue)
led_play.send(msg.build())
def csv_reader(file_name, client, record=True):
"""
Takes in a comma delineated csv file and sends its data via OSC over local network.
:param record: True records the sonification, false is for testing so you don't fill up
your computer with sonification recordings that are useless.
:param file_name: csv file path
:param client: OSC Client
:return: None
"""
with open(file_name) as csv_file:
the_csv = csv.reader(csv_file, delimiter=',')
for row in the_csv:
print(row)
row = [float(item) for item in row]
msg = osc_message_builder.OscMessageBuilder(address='/s_new')
msg.add_arg('avg_speed', arg_type='s')
msg.add_arg(abs(row[0]), 'f')
msg.add_arg('h1_pressure', arg_type='s')
msg.add_arg(row[1], 'f')
msg.add_arg('h1_speed', arg_type='s')
msg.add_arg(row[2], 'f')
msg.add_arg('h2_pressure', arg_type='s')
msg.add_arg(row[3], 'f')
msg.add_arg('h2_speed', arg_type='s')
msg.add_arg(row[4], 'f')
msg.add_arg('h3_pressure', arg_type='s')
msg.add_arg(row[5], 'f')
msg.add_arg('h3_speed', arg_type='s')
msg.add_arg(row[6], 'f')
msg = msg.build()
client.send(msg)
time.sleep(0.1)
def send(self, addr, v1=None, v2=None, v3=None, v4=None):
msg = osc_message_builder.OscMessageBuilder(address=addr)
for v in [v1, v2, v3, v4]:
if v is not None:
msg.add_arg(v)
msg = msg.build()
self.client.send(msg)
