MTEC Technical Production

Today we found a bunch of information, and here is said information.

Blue = Gabby

Brown/Red/Maroon..? = Miles

(ノ ゜Д゜)ノ ︵ OI∩┴

https://trac.v2.nl/wiki/pyOSC

^ This is in Python, it’s another implementation of OSC.

http://casparcg.com/wiki/CasparCG_OSC_Protocol

Server side software to relay OSC messages to a client.

http://archive.cnmat.berkeley.edu/OSC/src/sendOSC/

^ that’s for C, Client

oscP5 (for processing)

https://processing.org/reference/libraries/ download it here

http://www.sojamo.de/libraries/oscp5/ last updated in 2012, better than 2008

http://learning.codasign.com/index.php?title=Sending_and_Receiving_OSC_Data_Using_Processing basic example

Python OSC (… for Python, duh)

https://pypi.python.org/pypi/python-osc download it here or pip install it whatevs

https://github.com/attwad/python-osc last updated a few days ago

Examples include making a server and a client

SimpleOSC for python (requires pyOSC, which is linked up top)

http://www.ixi-audio.net/content/body_backyard_python.html supposedly simplifies the API or whatever for pyOSC

osc  (for javascript)

https://www.npmjs.org/package/osc Woo

So to compare them…

oscP5 for processing:

import oscP5.*;
import netP5.*;

OscP5 oscP5;
NetAddress myRemoteLocation;

void setup() {
size(400,400);

// start oscP5, telling it to listen for incoming messages at port 5001 */
oscP5 = new OscP5(this,5001);

// set the remote location to be the localhost on port 5001
myRemoteLocation = new NetAddress(“127.0.0.1”,5001);
}

void draw()
{

}

void mousePressed() {
// create an osc message
OscMessage myMessage = new OscMessage(“/test”);

myMessage.add(123); // add an int to the osc message
myMessage.add(12.34); // add a float to the osc message
myMessage.add(“some text!”); // add a string to the osc message

// send the message
oscP5.send(myMessage, myRemoteLocation);
}

void oscEvent(OscMessage theOscMessage)
{
// get the first value as an integer
int firstValue = theOscMessage.get(0).intValue();

// get the second value as a float  
float secondValue = theOscMessage.get(1).floatValue();

// get the third value as a string
String thirdValue = theOscMessage.get(2).stringValue();

// print out the message
print(“OSC Message Recieved: “);
print(theOscMessage.addrPattern() + ” “);
println(firstValue + ” ” + secondValue + ” ” + thirdValue);
}

Python OSC:

(server)

(client)

pyOSC

(send)

1. #!/usr/bin/env python3
2. from OSC import OSCClient, OSCMessage
3. client = OSCClient()
4. client.connect( (“localhost”, 7110) )
5. client.send( OSCMessage(“/user/1”, [1.0, 2.0, 3.0 ] ) )
6. client.send( OSCMessage(“/user/2”, [2.0, 3.0, 4.0 ] ) )
7. client.send( OSCMessage(“/user/3”, [2.0, 3.0, 3.1 ] ) )
8. client.send( OSCMessage(“/user/4”, [3.2, 3.4, 6.0 ] ) )
9. client.send( OSCMessage(“/quit”) )

(receive)

1. #!/usr/bin/env python3
2. from OSC import OSCServer
3. import sys
4. from time import sleep
5. server = OSCServer( (“localhost”, 7110) )
6. server.timeout = 0
7. run = True
8. # this method of reporting timeouts only works by convention
9. # that before calling handle_request() field .timed_out is
10. # set to False
11. def handle_timeout(self):
12.   self.timed_out = True
13. # funny python’s way to add a method to an instance of a class
14. import types
15. server.handle_timeout = types.MethodType(handle_timeout, server)
16. def user_callback(path, tags, args, source):
17.   # which user will be determined by path:
18.   # we just throw away all slashes and join together what’s left
19.   user = ”.join(path.split(“/”))
20.   # tags will contain ‘fff’
21.   # args is a OSCMessage with data
22.   # source is where the message came from (in case you need to reply)
23.   print (“Now do something with”, user,args[2],args[0],1-args[1])
24. def quit_callback(path, tags, args, source):
25.   # don’t do this at home (or it’ll quit blender)
26.   global run
27.   run = False
28. server.addMsgHandler( “/user/1”, user_callback )
29. server.addMsgHandler( “/user/2”, user_callback )
30. server.addMsgHandler( “/user/3”, user_callback )
31. server.addMsgHandler( “/user/4”, user_callback )
32. server.addMsgHandler( “/quit”, quit_callback )
33. # user script that’s called by the game engine every frame
34. def each_frame():
35.   # clear timed_out flag
36.   server.timed_out = False
37.   # handle all pending requests then return
38.   while not server.timed_out:
39.       server.handle_request()
40. # simulate a “game engine”
41. while run:
42.   # do the game stuff:
43.   sleep(1)
44.   # call user script
45.   each_frame()
46. server.close()

SimpleOSC:

from simpleOSC import initOSCClient, initOSCServer, setOSCHandler, sendOSCMsg, closeOSC, \

createOSCBundle, sendOSCBundle, startOSCServer

def myTest():

“”” a simple function that creates the necesary sockets and enters an enless

loop sending and receiving OSC

“””

import time # in this example we will have a small delay in the while loop

initOSCClient() # takes args : ip, port

initOSCServer() # takes args : ip, port, mode –> 0 for basic server, 1 for threading server, 2 for forking server

# bind addresses to functions

setOSCHandler(‘/check’, checkcheckcheck)

startOSCServer() # and now set it into action

print ‘ready to receive and send osc messages …’

try:

while 1:

sendOSCMsg(“/test”, [444]) # !! it sends by default to localhost ip “127.0.0.1” and port 9000

# create and send a bundle

bundle = createOSCBundle(“/test/bndlprt1”)

bundle.append(666) # 1st message appent to bundle

bundle.append(“the number of the beast”) # 2nd message appent to bundle

sendOSCBundle(bundle) # !! it sends by default to localhost ip “127.0.0.1” and port 9000

time.sleep(0.5) # you don’t need this, but otherwise we’re sending as fast as possible.

except KeyboardInterrupt:

print “closing all OSC connections… and exit”

closeOSC() # finally close the connection before exiting or program.

“”” Below a function dealing with OSC messages RECEIVED into Python.

Here you can set all the responders you need to deal with the incoming

OSC messages.

“””

def checkcheckcheck(addr, tags, data, source):

print “CHECK CHECK CHECK…”

print “received new osc msg from %s” % getUrlStr(source)

print “with addr : %s” % addr

print “typetags :%s” % tags

print “the actual data is : %s” % data

if __name__ == ‘__main__’: myTest()

lalala

For today, we re examined the code from the previous class and used the previous blog post as a reminder of what we had done. We looked through the various java files that were apart of the jar that were apart of the TUIO client. This included the library for OSC/TUIO itself and the wrapper for processing. We attempted to add functions for changing, inserting, or otherwise printing the port to no success. This did not work because java’s encapsulation methods are foreign to both Miles and Gabbys programming experience. So, we further tried to modify demo in processing to no avail. We used http://www.tutorialspoint.com/java/java_encapsulation.htm as a reference and looked into extending and implementing an interface in java in an attempt to make the code work. This also failed epically. For next class we will gather more information to further our progress.

Measurements are still in progress of transferring to a digital interface.

For today, we re-verified all steps to complete setup of sensor tile project. Port forwarding was setup and confirmed to work. Gabby was informed that some writing was already done regarding the use and setup of port forwarding. Following this, Miles and Gabby attempted to use the processing version of the TUIO client to no success. They looked at the code for TUIO client using a .jar de-compiler.  We attempted to make a modified .jar file. Also to no success even after attempting to edit the code in Eclipse. For next class we will set up Eclipse to export a .jar file and hopefully it will work. Taking more measurements of room and will will begin to convert measurements into autocac For next class we will be conducting more research at http://www.tuio.org/?java. We are also going to change the port to 514.