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 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 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 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 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 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 darray_cb(self, address_list, value_list, send_address):
try:
client = self.osc_clients[send_address[0]]
except:
return
if len(address_list) == 4:
client.set_detailed_display(int(address_list[3]) - 1)
client.detail_offset = 0
to_display = client.update_diagnostics_display(fader=True)
to_display.extend(client.update_detail_display(fader=True))
self.send(osc.Bundle(to_display), clients=[send_address[0]])
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 diagsw_cb(self, address_list, value_list, send_address):
if not self.osc_clients.has_key(send_address[0]):
self.cb_client_connected(send_address[0])
if value_list[0] == 0.0:
client = self.osc_clients[send_address[0]]
to_display = client.clear_display()
if client.topic == "/diagnostics":
client.topic = "/diagnostics_agg"
client.diag_db = self.diagnostics_agg_data
else:
client.topic = "/diagnostics"
client.diag_db = self.diagnostics_data
to_display.append(osc.Message("diaglbl", client.topic))
to_display.extend(client.update_diagnostics_display(fader=True))
to_display.extend(client.update_detail_display(fader=True))
self.send(osc.Bundle(to_display), clients=[send_address[0]])
def zero_command(self):
self.send(
osc.Bundle([
osc.Message('xy', 0.0, 0.0),
osc.Message('w', 0.0),
osc.Message('control', 0.0),
osc.Message('mapping', 0.0),
osc.Message('turbo', 0.0),
osc.Message('mapping_label', "holonomic"),
osc.Message('master', "")
]))
self.cmd.linear.x = 0.0
self.cmd.linear.y = 0.0
self.cmd.angular.z = 0.0
self.holonomic = True
self.running = False
def d_updown_cb(self, address_list, value_list, send_address):
if self.osc_clients.has_key(send_address[0]):
client = self.osc_clients[send_address[0]]
offset = client.diagnostics_offset
if address_list[1] == 'ddown':
client.diagnostics_offset += 1
fader = True
elif address_list[1] == 'dup':
client.diagnostics_offset -= 1
fader = True
elif address_list[1] == 'dfader':
max_offset = client.get_max_diagnostics_offset()
client.diagnostics_offset = int(
round(value_list[0] * max_offset))
fader = False
to_display = client.update_diagnostics_display(fader=fader)
self.send(osc.Bundle(to_display), clients=[send_address[0]])
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 reset_tabpage(self, client):
bundle = osc.Bundle()
bundle.add(osc.Message('xy', 0.0, 0.0))
bundle.add(osc.Message('w', 0.0))
if self.master_osc:
bundle.add(osc.Message('control', 1.0))
bundle.add(osc.Message('master', self.master_osc))
else:
bundle.add(osc.Message('control', 0.0))
bundle.add(osc.Message('master', ''))
if self.holonomic:
bundle.add(osc.Message('mapping_label', 'Holonomic'))
bundle.add(osc.Message('w/visible', 1.0))
else:
bundle.add(osc.Message('mapping_label', 'Differential'))
bundle.add(osc.Message('w/visible', 0.0))
bundle.add(osc.Message('mapping', 0.0))
if self.running:
bundle.add(osc.Message('turbo', 1.0))
else:
bundle.add(osc.Message('turbo', 0.0))
self.send(bundle, clients=[client])
def cb_client_connected(self, client):
"""
Callback for when a client has connected.
Add the client to the local dictionary of clients and initialize it.
"""
parent_client = self.parent.clients[client]
self.osc_clients[client] = DiagnosticsClient(parent_client.servicename,
parent_client.client_type,
self.start_topic)
if self.start_topic == "/diagnostics":
self.osc_clients[client].diag_db = self.diagnostics_data
elif self.start_topic == "/diagnostics_agg":
self.osc_clients[client].diag_db = self.diagnostics_agg_data
else:
raise ValueError
to_display = []
to_display.extend(self.osc_clients[client].clear_display())
to_display.append(
osc.Message("diaglbl", self.osc_clients[client].topic))
self.send(osc.Bundle(to_display), clients=[client])
self.osc_clients[client].active = True
def kv_updown_cb(self, address_list, value_list, send_address):
"""
Callback for up and down buttons as well as the slider for the
detailed display list
@param address_list: OSC address of the incoming message
@param value_list: OSC value arguments of the incoming message
@param send_address: IP and port of the originating client
"""
if self.osc_clients.has_key(send_address[0]):
client = self.osc_clients[send_address[0]]
if address_list[1] == 'kvdown':
client.detail_offset += 1
fader = True
elif address_list[1] == 'kvup':
client.detail_offset -= 1
fader = True
elif address_list[1] == 'kvfader':
max_offset = client.get_max_detail_offset()
client.detail_offset = int(round(value_list[0] * max_offset))
fader = False
to_display = client.update_detail_display(fader=fader)
self.send(osc.Bundle(to_display), clients=[send_address[0]])
def testBundle(self):
pingMsg = osc.Message("/ping")
bundle = osc.Bundle()
bundle.add(osc.Message("/pong"))
bundle.add(pingMsg)
bundle.add(osc.Message("/foo/bar", 1, 2))
d = defer.Deferred()
def ping(m, addr):
self.assertEquals(m, pingMsg)
d.callback(True)
d2 = defer.Deferred()
def foo(m, addr):
self.assertEquals(m, osc.Message("/foo/bar", 1, 2))
d2.callback(True)
self.receiver.addCallback("/ping", ping)
self.receiver.addCallback("/foo/*", foo)
self._send(bundle)
return defer.DeferredList([d, d2])
def send_osc_message(self, frame_id, to_send):
self.send(osc.Bundle(to_send))
def send(self, element, clients=None, tabpages=None):
"""
Send an OSC message or bundle to a client or list of clients
C{send} has several behaviors. Any combination of the below behaviors
may be used in custom tabpage handlers.
@param element: OSC message or bundle to send.
@type element: C{osc.Message} or C{osc.Bundle}
@param clients: Clients to send to.
@type clients: C{list}
@param tabpages: Tabpages to send to.
@type tabpages: C{list}
Send to All
===========
Sends an an element (C{osc.Message} or C{osc.Bundle})
prepended with all registered tabpage names to all clients found
on the network.
Example
-------
For this example, assume:
- Handler was registered with two names "tab1" and "tab2"
- There are two clients "client1" and "client2"
(These will actually be IP addresses, in practice)
The following command yields:
>>> self.send(osc.Message('fader',0.0))
osc.send(osc.Message('/tab1/fader',0.0),client1)
osc.send(osc.Message('/tab2/fader',0.0),client1)
osc.send(osc.Message('/tab1/fader',0.0),client2)
osc.send(osc.Message('/tab2/fader',0.0),client2)
Send to a particular client
===========================
Sends an element to a specified client (or list of clients).
Prepends all registered tabpage names to all the clients in the
list.
Example
-------
For this example, assume:
- Handler was registered with two names "tab1" and "tab2"
- There are two clients "client1" and "client2"
(These will actually be IP addresses, in practice)
The following command yields:
>>> self.send(osc.Message('fader',0.0),clients=['client1'])
osc.send(osc.Message('/tab1/fader',0.0),client1)
osc.send(osc.Message('/tab2/fader',0.0),client1)
Send to a particular tabpage
============================
Sends an element to all clients, but only a specified tabpage (or
list of tabpages).
Example
-------
For this example, assume:
- Handler was registered with two names "tab1" and "tab2"
- There are two clients "client1" and "client2"
(These will actually be IP addresses, in practice)
The following command yields:
>>> self.send(osc.Message('fader',0.0),tabpages=['tab1'])
osc.send(osc.Message('/tab1/fader',0.0),client1)
osc.send(osc.Message('/tab1/fader',0.0),client2)
Send to a particular client and tabpage
=======================================
Sends an element to a specific client (or a list of clients),
and a specified tabpage (or list of tabpages).
Example
-------
For this example, assume:
- Handler was registered with two names "tab1" and "tab2"
- There are two clients "client1" and "client2"
(These will actually be IP addresses, in practice)
The following command yields:
>>> self.send(osc.Message('fader',0.0),clients=['client1'],
... tabpages=['tab1'])
osc.send(osc.Message('/tab1/fader',0.0),client1)
"""
if type(element) is not osc.Message and type(element) is not osc.Bundle:
raise ValueError("element must be a message or bundle")
reg_clients = self.parent.clients
if clients:
if type(clients) is str:
iter_clients = [clients]
elif type (clients) is list:
iter_clients = clients
else:
iter_clients = reg_clients.keys()
if tabpages:
if type(tabpages) is str:
iter_tabpages = [tabpages]
elif type(tabpages) is list:
iter_tabpages = tabpages
else:
iter_tabpages = self.tabpage_names
for destination in iter_clients:
clientBundle = osc.Bundle()
for tab in iter_tabpages:
elem = copy.copy(element)
basename = '/' + tab
if type(elem) is osc.Bundle:
for msg in elem.getMessages():
clientBundle.add(osc.Message('/'.join([basename,
msg.address]),
*msg.getValues()))
elif type(elem) is osc.Message:
elem.address = '/'.join([basename, elem.address])
clientBundle.add(elem)
try:
dest_address = reg_clients[destination].send_tuple
self.parent._osc_sender.send(clientBundle, dest_address)
except KeyError:
continue
