def testMatchMessageWithWildcards(self):
def fooCallback(m):
pass
def barCallback(m):
pass
def bazCallback(m):
pass
def foobarCallback(m):
pass
n = dispatch.AddressNode()
n.addCallback("/foo", fooCallback)
n.addCallback("/bar", barCallback)
n.addCallback("/baz", bazCallback)
n.addCallback("/foo/bar", foobarCallback)
self.assertEquals(n.matchCallbacks(osc.Message("/*")),
set([fooCallback, barCallback, bazCallback]))
self.assertEquals(n.matchCallbacks(osc.Message("/spam")), set())
self.assertEquals(n.matchCallbacks(osc.Message("/ba*")),
set([barCallback, bazCallback]))
self.assertEquals(n.matchCallbacks(osc.Message("/b*r")),
set([barCallback]))
self.assertEquals(n.matchCallbacks(osc.Message("/ba?")),
set([barCallback, bazCallback]))
def testDispatching(self):
hello = osc.Message("/hello")
there = osc.Message("/there")
addr = ("0.0.0.0", 17778)
def cb(message, a):
self.assertEquals(message, hello)
self.assertEquals(addr, a)
state['cb'] = True
def cb2(message, a):
self.assertEquals(message, there)
self.assertEquals(addr, a)
state['cb2'] = True
recv = dispatch.Receiver()
recv.addCallback("/hello", cb)
recv.addCallback("/there", cb2)
state = {}
recv.dispatch(hello, addr)
self.assertEquals(state, {'cb': True})
state = {}
recv.dispatch(osc.Bundle([hello, there]), addr)
self.assertEquals(state, {'cb': True, 'cb2': True})
def cb_ros_switch_tabpage(self, msg):
if msg._connection_header['callerid'] != self.ros_name:
if not msg.tabpage.startswith('/'):
msg.tabpage = '/' + msg.tabpage
if msg.header.frame_id in self.clients:
self.sendToClient(osc.Message(msg.tabpage), client)
elif msg.header.frame_id == '':
self.sendToAll(osc.Message(msg.tabpage))
def mapping_callback(self, address_list, value_list, send_address):
if len(address_list) == 2:
self.holonomic = not self.holonomic
self.send(osc.Message('w/visible', int(self.holonomic)))
if self.holonomic:
self.send(osc.Message('mapping_label', "Holonomic"))
else:
self.send(osc.Message('mapping_label', "Differential"))
def multixy(self, address_list, value_list, send_address):
rospy.loginfo("multixy From: %s" % send_address[0])
print "/".join(address_list)
bundle = osc.Bundle()
bundle.add(osc.Message('xy', value_list[0], value_list[1]))
self.send(bundle, tabpages=['3', '4'])
self.send(osc.Message('xy', value_list[1], value_list[0]),
tabpages=['2'])
def testEquality(self):
self.assertEquals(osc.Bundle(), osc.Bundle())
self.assertNotEqual(osc.Bundle(), None)
self.assertNotEqual(osc.Bundle([osc.Message("/hello")]), osc.Bundle())
self.assertEquals(osc.Bundle([osc.Message("/hello")]),
osc.Bundle([osc.Message("/hello")]))
self.assertNotEqual(osc.Bundle([osc.Message("/hello")]),
osc.Bundle([osc.Message("/hello2")]))
def testMatchExact(self):
def callback(m):
pass
n = dispatch.AddressNode()
n.addCallback("/foo", callback)
self.assertEquals(n.matchCallbacks(osc.Message("/foo")),
set([callback]))
self.assertEquals(n.matchCallbacks(osc.Message("/bar")), set())
def cb_client_disconnected(self, client):
if client == self.master_osc:
self.holonomic = self.default_mode
self.running = False
self.send(
osc.Bundle(
[osc.Message('control', 0.0),
osc.Message('master', '')]))
self.master_osc = None
self.active_clients.discard(client)
def clear_diagnostics_display(self):
it = 1
to_display = []
while it <= self._len_diagnostics:
to_display.append(osc.Message("dled%i/color" % it, 'gray'))
to_display.append(osc.Message("dled%i" % it, 0.0))
to_display.append(osc.Message("dlabel%i/color" % it, 'gray'))
to_display.append(osc.Message("dlabel%i" % it, ''))
it += 1
to_display.append(osc.Message("dfader", 0.0))
return to_display
def turbo_callback(self, address_list, value_list, send_address):
if send_address[0] not in self.active_clients:
self.active_clients.add(send_address[0])
if send_address[0] == self.master_osc and len(address_list) == 2:
if value_list[0] == 1.0:
message = osc.Message("turbo", value_list[0])
self.send(message)
self.running = True
elif value_list[0] == 0.0:
message = osc.Message("turbo", value_list[0])
self.send(message)
self.running = False
def testMatchMessageWithRange(self):
def firstCallback(m):
pass
def secondCallback(m):
pass
n = dispatch.AddressNode()
n.addCallback("/foo/1", firstCallback)
n.addCallback("/foo/2", secondCallback)
self.assertEquals(n.matchCallbacks(osc.Message("/baz")), set())
self.assertEquals(n.matchCallbacks(osc.Message("/foo/[1-3]")),
set([firstCallback, secondCallback]))
self.assertEquals(n.matchCallbacks(osc.Message("/foo/[!1]")),
set([secondCallback]))
def testGetTypeTag(self):
m = osc.Message("/example")
self.assertEquals(m.getTypeTags(), "")
m.arguments.append(osc.StringArgument("egg"))
self.assertEquals(m.getTypeTags(), "s")
m.arguments.append(osc.StringArgument("spam"))
self.assertEquals(m.getTypeTags(), "ss")
def testMatchCallbackRangeWildcards(self):
def callback1(m):
pass
def callback2(m):
pass
n = dispatch.AddressNode()
n.addCallback("/foo1", callback1)
n.addCallback("/foo2", callback2)
self.assertEquals(n.matchCallbacks(osc.Message("/foo[1]")),
set([callback1]))
self.assertEquals(n.matchCallbacks(osc.Message("/foo[1-9]")),
set([callback1, callback2]))
self.assertEquals(n.matchCallbacks(osc.Message("/foo[4-6]")), set([]))
def send(message):
"""
Send message to Max.
OSC message is path + arguments in one string.
"""
global client
print "SEND: %s" % message
client.send(osc.Message(message), osc_send_address)
def testGetValues(self):
# tests calling txosc.osc.Message.getValues()
message = osc.Message("/foo", 2, True, 3.14159)
values = message.getValues()
self.failUnlessEqual(values[0], 2)
self.failUnlessEqual(values[1], True)
self.failUnlessEqual(values[2], 3.14159)
def send_messages(self):
self._send(osc.Message("/spam", "How are you?", 3.14159, True))
print("Goodbye.")
def _stop():
reactor.stop()
reactor.callLater(0.1, _stop)
def publish_cmd(self):
"""
Callback for a periodic publish update. Do not publish if there are no active clients.
"""
if self.master_osc and len(self.active_clients) != 0:
if self.master_osc and self.master_osc not in self.active_clients:
self.send(
osc.Bundle([
osc.Message('control', 0.0),
osc.Message('master', '')
]))
self.master_osc = None
elif self.master_osc:
self.send(osc.Message('control', 1.0),
clients=[self.master_osc])
self.pub.publish(self.cmd)
reactor.callLater(1.0 / self.minPublishFreq, self.publish_cmd)
def diag_cb(self, msg):
self.diagnostics_data.add_message(msg)
for addr, client in self.osc_clients.iteritems():
if client.active:
to_display = client.update_diagnostics_display(fader=True)
to_display.extend(client.update_detail_display(fader=True))
self.send(osc.Bundle(to_display), clients=[addr])
self.send(osc.Message("rostime", str(rospy.Time.now().to_sec())))
def cb_ros_vibrate(self, msg):
"""
Callback for the ROS /vibrate subscriber.
When called, sends a /vibrate message to all clients, causing capable
clients (iPhones) to vibrate
"""
self.sendToAll(osc.Message("/vibrate"))
def testToAndFromBinary(self):
self.assertRaises(osc.OscError, osc.Bundle.fromBinary,
"invalidbinarydata..")
self.assertRaises(osc.OscError, osc.Bundle.fromBinary,
"#bundle|invalidbinarydata..")
self.assertRaises(osc.OscError, osc.Bundle.fromBinary,
"#bundle\0\0\0\0\1\0\0\0\0hello")
self.assertRaises(osc.OscError, osc.Bundle.fromBinary,
"#bundle\0\0\0\0\1\0\0\0\0\0\0\0\5hellofdsfds")
def test(b):
binary = b.toBinary()
b2, leftover = osc.Bundle.fromBinary(binary)
self.assertEquals(leftover, "")
self.assertEquals(b, b2)
test(osc.Bundle())
test(osc.Bundle([osc.Message("/foo")]))
test(osc.Bundle([osc.Message("/foo"), osc.Message("/bar")]))
test(
osc.Bundle([
osc.Message("/foo"),
osc.Message("/bar", osc.StringArgument("hello"))
]))
nested = osc.Bundle([osc.Message("/hello")])
test(osc.Bundle([nested, osc.Message("/foo")]))
def create_blender_msg(self):
# Crée le message envoyé à blender à 60 fps
self.msg = osc.Message("/all_OSC_data")
for key, value in self.pool.items():
self.msg.add(key[0])
for i in range(2):
for item in value[i]: # value = [ [0, 0, 0] , [0, 0] ]
self.msg.add(item)
return self.msg
def testAddMessageArguments(self):
"""
Test adding arguments to a message
"""
m = osc.Message("/example", osc.IntArgument(33),
osc.BooleanArgument(True))
self.assertEquals(m.arguments[0].value, 33)
self.assertEquals(m.arguments[1].value, True)
m = osc.Message("/example", 33, True)
self.assertEquals(m.arguments[0].value, 33)
self.assertEquals(m.arguments[1].value, True)
m = osc.Message("/example")
m.add(33)
self.assertEquals(m.arguments[0].value, 33)
self.assertEquals(m.arguments[0].typeTag, "i")
m.add(True)
self.assertEquals(m.arguments[1].typeTag, "T")
def testFunctionFallback(self):
hello = osc.Message("/hello")
addr = ("0.0.0.0", 17778)
def fb(message, address):
self.assertEquals(message, hello)
recv = dispatch.Receiver()
recv.setFallback(fb)
recv.dispatch(hello, addr)
def cb_tabpage_active(self, client, tabpage):
"""
Callback for when a client has opened a tabpage handled by this handler
"""
if self.osc_clients.has_key(client):
self.osc_clients[client].active = True
else:
self.cb_client_connected(client)
self.send(osc.Message("diaglbl", self.osc_clients[client].topic),
clients=[client])
def clear_detail_display(self):
it = 1
to_display = []
self.detail_display = None
while it <= self._len_detail:
to_display.append(osc.Message("key%i" % it, ''))
to_display.append(osc.Message("value%i" % it, ''))
it += 1
to_display.append(osc.Message("kvfader", 0.0))
to_display.append(osc.Message("deviceled/color", "gray"))
to_display.append(osc.Message("deviceled", 0.0))
to_display.append(osc.Message("name", ""))
to_display.append(osc.Message("hardware_id", ""))
to_display.append(osc.Message("message", ""))
to_display.append(osc.Message("stamp", ""))
return to_display
def testSingleMessage(self):
pingMsg = osc.Message("/ping")
d = defer.Deferred()
def ping(m, addr):
self.assertEquals(m, pingMsg)
d.callback(True)
self.receiver.addCallback("/ping", ping)
self._send(pingMsg)
return d
def testGetMessages(self):
m1 = osc.Message("/foo")
m2 = osc.Message("/bar")
m3 = osc.Message("/foo/baz")
b = osc.Bundle()
b.add(m1)
self.assertEquals(b.getMessages(), set([m1]))
b = osc.Bundle()
b.add(m1)
b.add(m2)
self.assertEquals(b.getMessages(), set([m1, m2]))
b = osc.Bundle()
b.add(m1)
b.add(osc.Bundle([m2]))
b.add(osc.Bundle([m3]))
self.assertEquals(b.getMessages(), set([m1, m2, m3]))
def xypad_ros_cb(self, msg):
try:
if msg._connection_header['callerid'] != self.ros_name:
(control, control_dict,
to_send) = self.osc_populate_common(msg)
if [msg.x, msg.y] != control_dict[None]:
control_dict[None] = [msg.x, msg.y]
to_send.append(osc.Message(control, *control_dict[None]))
self.send_osc_message(msg.header.frame_id, to_send)
except KeyError:
pass
def create_message_manually(path, types, *args):
"""
The used specified the type tags.
"""
def _exit_with_error(message):
global RETURN_VALUE
if reactor.running:
reactor.stop()
print(message)
RETURN_VALUE = 1 # error
if len(types) != len(args):
_exit_with_error(
"The length of the type string must match the number of arguments."
)
return
message = osc.Message(path)
try:
for value, typetag in zip(args, types):
verb("Creating argument for %s with type tag %s" %
(value, typetag))
cast = str
if typetag == "i":
cast = int
elif typetag == "f":
cast = float
elif typetag in ["T", "F"]:
cast = None
elif typetag == "t":
cast = None
elif typetag == "N":
cast = None
elif typetag == "I":
cast = None
elif typetag == "":
cast = None
if cast is not None:
try:
casted = cast(value)
except ValueError, e:
_exit_with_error(
"Error converting an argument to type tag" + str(e))
return
else:
casted = value
arg = osc.createArgument(casted, typetag)
verb("Adding argument %s." % (arg))
message.add(arg)
except osc.OscError, e:
_exit_with_error(str(e))
return None
def multifader_ros_cb(self, msg):
try:
if msg._connection_header['callerid'] != self.ros_name:
(control, control_dict,
to_send) = self.osc_populate_common(msg)
if list(msg.values) != control_dict[None]:
control_dict[None] = list(msg.values)
to_send.append(osc.Message(control, *control_dict[None]))
self.send_osc_message(msg.header.frame_id, to_send)
except KeyError:
pass
