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