def loop(serial, host, port):
osctx = osc_init( (host, port) )
bitadev = bitalino_init(serial)
if not bitadev:
raise Exception("Coultdn't open the BITalino device")
try:
print "Entering reading loop..."
while True:
samples = bitadev.read()
time.sleep(0.005)
#bitadev.trigger(digitalOutput)
for s in samples:
msg = OSCMessage()
msg.setAddress("/biosample")
out = []
for sval in s:
out.append(sval / 1024)
msg.append(out)
#print msg
osctx.send( msg )
except KeyboardInterrupt as e:
print "Looks like you wanna leave. Good bye!"
finally:
bitadev.stop()
bitadev.close()
def hardware_callback(addr, tags, d, client_address):
#d is data
h_id = int(addr.split("/")[-1])
event = None
error = False
if h_id == JUNCTION:
if len(d) == 13:
#create event object
event = pygame.event.Event(NETWORK_HARDWARE,{"hardware_id":JUNCTION,
"topRowOn":d[0],1:d[1],2:d[2],3:d[3],4:d[4],5:d[5],6:d[6],
7:d[7],8:d[8],9:d[9],10:d[10],11:d[11],12:d[12]})
else:
error = True
elif h_id == SCIENCE:
event = pygame.event.Event(NETWORK_HARDWARE,{"hardware_id":SCIENCE,"s1":True})
elif h_id == COMMANDER:
event = pygame.event.Event(NETWORK_HARDWARE,{"hardware_id":COMMANDER,"has_power":True})
elif h_id == RADIO:
event = pygame.event.Event(NETWORK_HARDWARE,{"hardware_id":RADIO,"frequency":55})
if event != None:
pygame.event.post(event)
if error:
#object malformed, return error
msg = OSCMessage("/user/1")
msg.append("Error")
server.client.sendto(msg,client_address)
def record_data(self):
if(self.port is None):
return None
print "Logging started"
while 1:
localtime = datetime.now()
current_time = str(localtime.hour)+":"+str(localtime.minute)+":"+str(localtime.second)+"."+str(localtime.microsecond)
log_string = current_time
results = {}
for index in self.sensorlist:
(name, value, unit) = self.port.sensor(index)
log_string = log_string + ","+str(value)
results[obd_sensors.SENSORS[index].shortname] = value;
#send sensor data via OSC
message = OSCMessage()
message.setAddress("/"+obd_sensors.SENSORS[index].shortname)
message.append(value)
self.client.send(message)
gear = self.calculate_gear(results["rpm"], results["speed"])
log_string = log_string #+ "," + str(gear)
#send gear via OSC
message = OSCMessage()
message.setAddress("/gear")
message.append(gear)
self.client.send(message)
self.log_file.write(log_string+"\n")
def fader_callback(path, tags, args, source):
print ("path", path)
print ("args", args)
print ("source", source)
msg=OSCMessage("/1/rotary1")
msg.append(args);
client.send(msg)
def send_event():
spectral_densities = ['filled', 'packed', 'opaque','translucent','transparent','empty']
# fill blanks
data = ['']*17*3
#onset, continuant, termination
data[0] = 'attack'
#elegimos el de mayor momento transversal
i = [l for l in tree.lep_pt].index(max(tree.lep_pt))
#duration, based on momento transversal .. lep_pt
data[1] = mapValue(tree.lep_pt[i],0,100000,0.1,10)
#Spectrum types: electrones : inarmonico , muones: granular
data[10] = 'inharmonic' if tree.lep_type[i] == 11 else 'granular'
#Spectrum occupation: angulo
data[11] = 'center'
#Spectrum density: lepton energy .. lep_E
data[16] = spectral_densities[int(mapValue(tree.lep_E[i],0,100000,0,5))]
bundle = OSCBundle()
msg = OSCMessage("/"+args.messagename)
for d in data:
msg.append(d)
bundle.append(msg)
client.send(bundle)
def sendMessage():
msg = OSCMessage()
msg.setAddress("/oscTest")
msg.append(100)
print "sending '/oscTest 100' message to SuperCollider"
client.send(msg)
timedSendMessage() # recursive call, keeps the timer going
def nunchuk(self, state):
"""
Extract acceleration, pitch, roll and both buttons
from the nunchuk.
"""
# Need to calculate pitch and roll here...
a_x = state['acc'][0] - self.cal_n_x
a_y = state['acc'][1] - self.cal_n_y
a_z = state['acc'][2] - self.cal_n_z
roll = atan(a_x/a_z)
pitch = atan(a_y/a_z*cos(roll))
msg = OSCMessage('/nunchuk/acc')
msg.append((a_x, a_y, a_z))
self.client.sendto(msg=msg, address=self.address)
msg = OSCMessage('/nunchuk/orientation')
msg.append((pitch, roll))
self.client.sendto(msg=msg, address=self.address)
msg = OSCMessage('/nunchuk/joystick')
msg.append(state['stick'])
self.client.sendto(msg=msg, address=self.address)
msg_z = OSCMessage('/nunchuk/button/z')
msg_c = OSCMessage('/nunchuk/button/c')
z = 0
c = 0
if state['buttons'] in [1, 3]:
z = 1
if state['buttons'] in [2,3]:
c = 1
msg_z.append(z)
msg_c.append(c)
self.client.sendto(msg=msg_z, address=self.address)
self.client.sendto(msg=msg_c, address=self.address)
def send(self, sample):
mes = OSCMessage(self.address)
mes.append(sample.channel_data)
try:
self.client.send(mes)
except:
return
def serve_forever(self):
for msg in self.json_to_osc_q:
osc_msg = OSCMessage(self.osc_command_name)
osc_msg.append(msg[0]) #HTTP verb
osc_msg.append(msg[1]) #HTTP path
osc_msg.append(msg[2]) #content
self.osc_client.send(osc_msg)
def send_oscbundle(self):
# send a bundle with current bpm and polar coordinates of
# sound-objects relative to player
# /game/bpm
client = OSCClient()
bpm = OSCMessage()
bpm.setAddress("/game/bpm")
bpm.append(self.player['bpm'])
bundle = OSCBundle()
bundle.append(bpm)
# /game/sndobj/id-bola (ang, mod)
scn = bge.logic.getCurrentScene()
play = scn.objects["player"]
for ball in self.soundobjects:
ballpos = ball.worldPosition
vect = mathutils.Vector((0,1))
dist = play.getVectTo(ballpos)[0]
vect2 = play.getVectTo(ballpos)[2].to_2d()
angle = math.degrees(-vect.angle_signed(vect2))
#print("angle ", angle, "distancia ",dist)
data = (angle, dist)
# append data to bundle
msg = OSCMessage()
tag = "/game/sndobj/position/" + str(ball['id'])
msg.setAddress(tag)
msg.append(data)
bundle.append(msg)
#print(msg)
#gl.client is a tuple in gl with ip and port
client.sendto(bundle, gl.send_to)
def messageServer(self, messagePath, argument):
client = OSCClient()
client.connect((self.serverIP, self.serverPort))
message = OSCMessage(messagePath)
message.append(argument)
client.send(message)
def send(self,name,val=None):
msg = OSCMessage(name)
if val is not None:
msg.append(val)
r = self.client.send(msg)
self.osc_messages_sent += 1
return r
def serialComms(): while run: proximity = ser.readline() proxMsg = OSCMessage() proxMsg.setAddress(OSCAddress) proxMsg.append(proximity) columnClient.send(proxMsg)
def __init__(self, address):
OSCServer.__init__(self, ('', 0))
self.client.connect(address)
host, port = self.client.socket.getsockname()
# print "I believe we have an OSC Server listening on: ",host," ",port
print port
self.focused = False
#self.server_host = host
#self.server_port = port
self.prefix = DEFAULT_PREFIX
self.addMsgHandler('default', self.monome_handler)
self.addMsgHandler('/sys/connect', self.sys_misc)
self.addMsgHandler('/sys/disconnect', self.sys_misc)
self.addMsgHandler('/sys/id', self.sys_misc)
self.addMsgHandler('/sys/size', self.sys_size)
self.addMsgHandler('/sys/host', self.sys_host)
self.addMsgHandler('/sys/port', self.sys_port)
self.addMsgHandler('/sys/prefix', self.sys_prefix)
self.addMsgHandler('/sys/rotation', self.sys_misc)
# handshake
msg = OSCMessage("/sys/host")
msg.append(host)
self.client.send(msg)
msg = OSCMessage("/sys/port")
msg.append(port)
self.client.send(msg)
msg = OSCMessage("/sys/info")
self.client.send(msg)
def toggleMuteGroup(channel, state): stringChannel = str(channel) muteAddress = '/config/mute/' + stringChannel msg = OSCMessage(muteAddress) msg.append(state) client.send(msg) print msg
class SendOSC(object):
def __init__(self):
self.osc_message = None
self.osc_client = OSCClient()
self.osc_message = OSCMessage()
self.ip = ""
self.port = 0
def connect(self, ip="localhost", port=8080):
self.ip = ip
self.port = port
self.osc_client.connect((self.ip, self.port))
def send(self, address, value):
self.osc_message.setAddress(address)
self.osc_message.append(value)
self.osc_client.send(self.osc_message)
def send_distane(self, distance):
oscdump = "/dumpOSC/DistanceTipTarget"
self.send(oscdump, distance)
def send_needle_tip_position(self, x, y, z):
oscdump = "/dumpOSC/needltip/x"
self.send(oscdump, x)
oscdump = "/dumpOSC/needltip/y"
self.send(oscdump, y)
oscdump = "/dumpOSC/needltip/z"
self.send(oscdump, z)
def espaces_callback(path, tags, args, source):
msg_string = ""
msg_string += "\n\tpath : %s" % path
msg_string += "\n\ttags : %s" % tags
msg_string += "\n\targs : %s" % args
msg_string += "\n\tsource :%s" % str(source)
print "OSCServer received: %s\nfrom %s.\n" % (msg_string, getUrlStr(source))
ir_params = { 'duration' : float(args[4]),
'nu' : float(args[5]),
'sampling_rate' : float(args[6]),
'ev_params' : {'space': str(args[1]), 'c':float(args[2]), 'j_max':int(args[3]),'F':list(args[7:])},
}
command = espace_client.handle_request(ir_params)
# send reply to the client
reply_port = int(args[0])
reply_addresse = (source[0], reply_port)
msg = OSCMessage("/pd")
msg.append(command['saved_audio_path'])
server.client.sendto(msg,reply_addresse,timeout=1)
print "OSCServer send:\n\t%s\nto %s.\n" %(msg,reply_addresse)
return OSCMessage("/")
def sendOSCMessage(pin, value):
# LOW/0 = pressed and HIGH/1 = released
# example: "/b/p 12 0"
if (value == 0):
obj = OSCMessage("/b/p")
else:
obj = OSCMessage("/b/r")
obj.append(int(pin))
def send_osc_message(name, *args): msg = OSCMessage(name) for arg in args: msg.append(arg) try: client.send(msg, 0) except Exception, e: pass
def handle_sample(self, sample):
mes = OSCMessage(self.address)
mes.append(sample.channel_data)
# silently pass if connection drops
try:
self.client.send(mes)
except:
return
def send(self, path, value):
try:
message = OSCMessage(path)
message.append(value)
self.osc.send(message)
except:
print "Error connecting to OSC server. Re-initiating Connection."
self.setup_connection()
def send(self, name, val=None):
if self.current_bundle is None:
super(BundledMixin,self).send(name,val)
else:
self.osc_messages_sent += 1
#log("Bundle: %s\n" % self.current_bundle)
msg = OSCMessage(name)
if val is not None:
msg.append(val)
self.current_bundle.append(msg)
def sendOSCnextlevel():
client = OSCClient()
msg = OSCMessage()
# gl.client is a tuple in gl with ip and port
address = "/game/nextlevel"
msg.setAddress(address)
msg.append(currentlevel)
client.sendto(msg, gl.send_to)
#print('Send message example =', msg, "to ", gl.send_to)
return
def _oscHandler(self, addr, tags, stuff, source):
addrTokens = addr.lstrip('/').split('/')
## list of all receivers
if ((addrTokens[0].lower() == "localnet")
and (addrTokens[1].lower() == "receivers")):
## as good, if not better than a ping
self.lastPingTime = time.time()
print "got receivers %s"%(stuff[0])
for rcvr in stuff[0].split(','):
self.allReceivers[rcvr] = rcvr
if(self.subscribedToAll and not self.subscribedReceivers):
self.subscribeToAll()
## hijack /LocalNet/Add !
elif ((addrTokens[0].lower() == "localnet")
and (addrTokens[1].lower() == "add")):
ip = getUrlStr(source).split(":")[0]
port = int(stuff[0])
print "adding %s:%s to PantallaServer" % (ip, port)
self.allClients[(ip,port)] = addrTokens[2]
## hijack a /LocalNet/ListReceivers
elif ((addrTokens[0].lower() == "localnet")
and (addrTokens[1].lower().startswith("listreceiver"))):
ip = getUrlStr(source).split(":")[0]
port = int(stuff[0])
## send list of receivers to client
msg = OSCMessage()
msg.setAddress("/LocalNet/Receivers")
msg.append(self.name)
print "got a request for receivers from %s:%s"%(ip,port)
try:
#self.oscClient.connect((ip, port))
self.oscClient.sendto(msg, (ip, port))
#self.oscClient.connect((ip, port))
except OSCClientError:
print "no connection to %s:%s, can't send list of receivers"%(ip,port)
## actual message from AEffect Network !!
elif (addrTokens[0].lower() == "aeffectlab"):
self.messageQ.put((addrTokens[1],
addrTokens[2],
stuff[0].decode('utf-8')))
self.messageQ.put((addrTokens[1],
addrTokens[2],
stuff[0].decode('utf-8')))
## ping
if ((addrTokens[0].lower() == "localnet")
and (addrTokens[1].lower() == "ping")):
self.lastPingTime = time.time()
# forward to clients
for (ip,port) in self.allClients.keys():
try:
#self.oscClient.connect((ip, int(port)))
self.oscClient.sendto(self.oscPingMessage, (ip, int(port)))
#self.oscClient.connect((ip, int(port)))
except OSCClientError:
print ("no connection to %s:%s, can't send bang"%(ip,port))
def send_osccreation(self, lista):
# crea los objetos en el sound engine
client = OSCClient()
msg = OSCMessage()
# gl.client is a tuple in gl with ip and port
address = "/game/create"
msg.setAddress(address)
msg.append(lista)
client.sendto(msg, gl.send_to)
#print('Send message example =', msg, "to ", gl.send_to)
return
def send_destroy(self,id):
#
client = OSCClient()
msg = OSCMessage()
# gl.client is a tuple in gl with ip and port
address = "/game/sndobj/destroy"
msg.setAddress(address)
msg.append(id)
client.sendto(msg, gl.send_to)
#print('Send message example =', msg, "to ", gl.send_to)
return
def send_choque(self):
#
client = OSCClient()
msg = OSCMessage()
# gl.client is a tuple in gl with ip and port
address = "/player/choque"
msg.setAddress(address)
msg.append(0)
client.sendto(msg, gl.send_to)
#print('Send message example =', msg, "to ", gl.send_to)
return
def sendMessage():
msg = OSCMessage()
msg.setAddress("/oscTest")
msg.append(100)
print "Sending '/oscTest 100' message to SuperCollider"
try:
client.send(msg)
except:
print "Waiting for SuperCollider to become available..."
pass
timedSendMessage() # recursive call, keeps the timer going
def serialComms():
while run:
proximity = ser.readline()
proxMsg = OSCMessage()
proxMsg.setAddress(OSCAddress)
proxMsg.append(proximity)
try:
columnClient.send(proxMsg)
except:
print("client unavailable")
pass
def send_stop(self):
# da stop al soundengine
client = OSCClient()
msg = OSCMessage()
# gl.client is a tuple in gl with ip and port
address = "/game/stop"
msg.setAddress(address)
msg.append(0)
client.sendto(msg, gl.send_to)
#print('Send message example =', msg, "to ", gl.send_to)
return
def send(self, address, param = None):
if self.client != None:
msg = OSCMessage(address)
if param != None:
# when sending values, ignore ACK response
self.last_cmd_time = time.time()
self.last_cmd_addr = address
if isinstance(param, list):
msg.extend(param)
else:
msg.append(param)
else:
# sending parameter request, don't ignore response
self.last_cmd_time = 0
self.last_cmd_addr = ''
self.client.send(msg)
def SendUI(oscaddress,oscargs=''):
oscmsg = OSCMessage()
oscmsg.setAddress(oscaddress)
oscmsg.append(oscargs)
osclientlj = OSCClient()
osclientlj.connect((gstt.TouchOSCIP, gstt.TouchOSCPort))
#print("MIDI Aurora sending UI :", oscmsg, "to",gstt.TouchOSCIP,":",gstt.TouchOSCPort)
try:
osclientlj.sendto(oscmsg, (gstt.TouchOSCIP, gstt.TouchOSCPort))
oscmsg.clearData()
except:
log.err('Connection to Aurora UI refused : died ?')
pass
def SendAU(oscaddress,oscargs=''):
oscmsg = OSCMessage()
oscmsg.setAddress(oscaddress)
oscmsg.append(oscargs)
osclientlj = OSCClient()
osclientlj.connect((gstt.myIP, 8090))
# print("MIDI Aurora sending itself OSC :", oscmsg, "to localhost:8090")
try:
osclientlj.sendto(oscmsg, (gstt.myIP, 8090))
oscmsg.clearData()
except:
log.err('Connection to Aurora refused : died ?')
pass
def processGaze(g):
global lastData, t, samples
conf = g['confidence']
if conf > 0.5:
if lastData <> '' and lastData == g['norm_pos']:
return
lastData = g['norm_pos']
t1 = current_milli_time()
msg = OSCMessage("/pupil/pos")
msg.append(g['norm_pos'])
client.send(msg)
samples = samples + 1
if t1 - t > 1000:
print 'FPS:', samples
t = t1
samples = 0
def loopend(self,arrCmd):
oscm = OSCMessage("/live/clip/loop/end")
oscm.append(self.int_or_string(arrCmd[0])) #track
oscm.append(int(arrCmd[1])) #slot
if arrCmd[2].lower() == 'bars':
oscm.append((float(arrCmd[3]) - 1) * self.parent.signature_numerator) #position in beats
else:
oscm.append(float(arrCmd[3]) - 1) #position in beats
return oscm
def send_event(tree=None):
try:
bundle = OSCBundle()
msg = OSCMessage("/entry")
if tree is None:
msg.append(random())
msg.append(random())
msg.append(random(), 'b')
else:
msg.append(tree.lbNumber)
msg.append(tree.mu)
msg.append(tree.lep_eta[0], 'b')
bundle.append(msg)
client.send(bundle)
except OSCClientError, e:
printc( "\OSCClientError: Connection refused on port %s." % osc_port, 'e')
def SendResol(oscaddress, oscargs):
oscmsg = OSCMessage()
oscmsg.setAddress(oscaddress)
oscmsg.append(oscargs)
osclientresol = OSCClient()
osclientresol.connect((oscIPresol, oscPORTresol))
print("lj23layers sending OSC message : ", oscmsg, "to Resolume",
oscIPresol, ":", oscPORTresol)
try:
osclientresol.sendto(oscmsg, (oscIPresol, oscPORTresol))
oscmsg.clearData()
except:
print('Connection to Resolume refused : died ?')
pass
def handleMessage(self):
global osc_client
# echo message back to client
print "we got a msssagatege that said: " + self.data
try:
# osc_client.send( OSCMessage("/user/2", [2.0, 3.0, 4.0 ] ) )
oscmsg = OSCMessage()
oscmsg.setAddress("/startup")
oscmsg.append(str(self.data))
osc_client.send(oscmsg)
except Exception, e:
print "sending osc message didn't work: " + str(e)
def commitFrame(self):
"""
A typical TUIO bundle will contain an initial ALIVE message, followed by an arbitrary number of SET messages
that can fit into the actual bundle capacity and a concluding FSEQ message. A minimal TUIO bundle needs to
contain at least the compulsory ALIVE and FSEQ messages. The FSEQ frame ID is incremented for each delivered
bundle, while redundant bundles can be marked using the frame sequence ID -1.
/tuio/2Dcur alive s_id0...s_idN
/tuio/2Dcur set s_id x_pos y_pos x_vel y_vel m_accel
/tuio/2Dcur fseq f_id
"""
bundle = OSCBundle()
if len(self.alive) == 0:
aliveMsg = OSCMessage("/tuio/2Dcur")
aliveMsg.append('alive')
bundle.append(aliveMsg)
else:
aliveMsg = OSCMessage("/tuio/2Dcur")
aliveMsg.append('alive')
for cursor in self.alive:
aliveMsg.append(cursor.sid)
bundle.append(aliveMsg)
for cursor in self.alive:
msg = OSCMessage()
# TUIO message: /tuio/2Dcur set s x y X Y m
# s: Session ID (temporary object ID) (int32)
# x, y: Position (float32)
# X, Y: Velocity vector (motion speed & direction) (float32)
# m: Motion acceleration (float32)
msg.setAddress("/tuio/2Dcur")
msg.extend([
'set', cursor.sid, cursor.x, cursor.y, cursor.X, cursor.Y,
cursor.m
])
bundle.append(msg)
frameMsg = OSCMessage("/tuio/2Dcur")
frameMsg.append('fseq')
frameMsg.append(self.fseqCount)
bundle.append(frameMsg)
self.client.send(bundle)
self.fseqCount = (self.fseqCount + 1) % sys.maxint
def fader_callback(path, tags, args, source):
print("path", path)
print("args", args)
print("source", source)
value = int(args[0] * 10)
if value > 1:
led[0].on()
if value > 2:
led[1].on()
if value > 3:
led[2].on()
if value > 4:
led[3].on()
if value > 5:
led[4].on()
if value > 6:
led[5].on()
if value > 7:
led[6].on()
if value > 8:
led[7].on()
if value < 1:
led[0].off()
if value < 2:
led[1].off()
if value < 3:
led[2].off()
if value < 4:
led[3].off()
if value < 5:
led[4].off()
if value < 6:
led[5].off()
if value < 7:
led[6].off()
if value < 8:
led[7].off()
msg = OSCMessage("/1/rotary1")
msg.append(args)
client.send(msg)
def cleanTagAndSendText(text):
## removes punctuation
text = re.sub(r'[.,;:!?*/+=\-&%^/\\_$~()<>{}\[\]]', ' ', text)
## removes some bad words
text = re.sub(r'(f *u *c *k)', 'tuck', text)
text = re.sub(r'(s *h *i *t)', 'isht', text)
text = re.sub(r'(c *o *c *k)', 'dock', text)
text = re.sub(r'(d *i *c *k)', 'wick', text)
text = re.sub(r'(c *u *n *t)', 'grunt', text)
text = re.sub(r'(p *u *s *s *y)', 'juicy', text)
text = re.sub(r'(b *i *t *c *h)', 'itch', text)
text = re.sub(r'(a *s *s)', 'grass', text)
## replaces double-spaces with single space
text = re.sub(r'( +)', ' ', text)
taggedText = pos_tag(text.split())
for (word, tag) in taggedText:
print "(%s:%s)" % (word, tag),
print " "
## log
logFile.write(strftime("%Y%m%d-%H%M%S", localtime()) + "***" + text + "\n")
logFile.flush()
## forward to all subscribers
msg = OSCMessage()
msg.setAddress("/NotTooPublic/response")
msg.append(" ".join([str(i[0]) for i in taggedText]))
msg.append(" ".join([str(i[1]) for i in taggedText]))
delQ = Queue()
for (ip, port) in myOscSubscribers:
try:
myOscClient.connect((ip, port))
myOscClient.sendto(msg, (ip, port))
myOscClient.connect((ip, port))
except OSCClientError:
print "no connection to %s : %s, can't send message" % (ip, port)
delQ.put((ip, port))
while not delQ.empty():
del myOscSubscribers[delQ.get()]
def send(nodes, jeu):
mean_p = 0.0
mean_dp = 0.0
for node in nodes:
try:
msg = OSCMessage("/%i" % node.ip)
# presure and presure derivative (constants setted to assure equal mean)
p = gate(1.5 * node.current)
dp = gate(5 * (node.current - node.previous))
if jeu == "2osc":
xA0, xA1, xA2 = dp, p, 0
xB0, xB1, xB2 = 0, 0, 0
xC0, xC1, xC2 = 0, 0, 0
elif jeu == "3chords":
p /= 3.
dp /= 3.
xA0, xA1, xA2 = dp, p, dp + p
xB0, xB1, xB2 = dp, p, dp + p
xC0, xC1, xC2 = dp, p, dp + p
if DEBUG:
print("%i %f %f %f %f %f %f %f %f %f" %
(node.ip, xA0, xA1, xA2, xB0, xB1, xB2, xC0, xC1, xC2))
msg.append(xA0)
msg.append(xA1)
msg.append(xA2)
msg.append(xB0)
msg.append(xB1)
msg.append(xB2)
msg.append(xC0)
msg.append(xC1)
msg.append(xC2)
bundle = OSCBundle()
bundle.append(msg)
client.send(bundle)
except Exception as e:
print(node)
print(e)
if DEBUG:
mean_p += p
mean_dp += dp
if DEBUG:
print("mean_p %f mean_dp %f" % (mean_p, mean_dp))
def SendLJ(oscaddress, oscargs=''):
oscmsg = OSCMessage()
oscmsg.setAddress(oscaddress)
oscmsg.append(oscargs)
osclientlj = OSCClient()
osclientlj.connect((redisIP, 8002))
#print("lj23layers for", name, "sending OSC message :", oscmsg, "to", redisIP, ":8002")
if gstt.debug > 0:
print("lj23layers for", name, "sending OSC message :", oscmsg, "to",
redisIP, ":8002")
try:
osclientlj.sendto(oscmsg, (redisIP, 8002))
oscmsg.clearData()
except:
print('Connection to LJ refused : died ?')
pass
def sendMsgBlocking(self,msg,*args): packetNumber = self.getPacketNumber() print "Sending %r (#%i)..." % (msg,packetNumber) omcall = Call() omcall.result = None omcall.done = False self.calls[packetNumber] = omcall message = OSCMessage() message.setAddress(msg) message.append(packetNumber) for arg in args: message.append(arg) self.transport.write(message.getBinary()) now = time.time() while not omcall.done: time.sleep(INGEN_CALL_POLLTIME) distance = time.time() - now if distance > INGEN_CALL_TIMEOUT: print "timeout" break del self.calls[packetNumber] return omcall.result
def cleanTagAndSendText(text):
## removes punctuation
text = re.sub(r'[.,;:!?*/+=\-&%^/\\_$~()<>{}\[\]]', ' ', text)
## replaces double-spaces with single space
text = re.sub(r'( +)', ' ', text)
## log
now = datetime.now(utc)
logFile.write(now.isoformat() + " *** " + text + "\n")
logFile.flush()
## forward to all subscribers
msg = OSCMessage()
msg.setAddress("/airmsg/response")
msg.append(text.encode('utf-8'))
try:
myOscClient.connect((DISPLAY_ADDR, DISPLAY_PORT))
myOscClient.sendto(msg, (DISPLAY_ADDR, DISPLAY_PORT))
myOscClient.connect((DISPLAY_ADDR, DISPLAY_PORT))
except OSCClientError:
print("no connection to %s : %s, can't send message" %
(DISPLAY_ADDR, DISPLAY_PORT))
def handleMsg(self,oscAddress, tags, data, client_address):
global machine
global client_lucibox
global client_nodejs
global client_of
print("OSC message received on : "+oscAddress)
splitAddress = oscAddress.split("/")
#DEBUG
#print(splitAddress)
############## SERVICE itself #############
if(splitAddress[1]=="app"):
# TODO : restart dedicated services here
if(splitAddress[2]=="close"):
print("closing the app")
quit_app()
if(splitAddress[2]=="start"):
print("starting the app")
start_app()
if(splitAddress[2]=="restart"):
print("restart the app")
quit_app()
time.sleep(2)
start_app()
############## RPI itself #############
elif(splitAddress[1]=="rpi"):
if(splitAddress[2]=="shutdown"):
print("Turning off the rpi")
powerOff()
if(splitAddress[2]=="read"):
read_disk()
if(splitAddress[2]=="write"):
write_disk()
############# LUCIBOX ####
elif(splitAddress[1]=="lucibox"):
separator="/"
splitAddress.remove("lucibox")
finalAddress = separator.join(splitAddress)
oscmsg = OSCMessage()
oscmsg.setAddress(finalAddress)
oscmsg.append(data)
client_lucibox.send(oscmsg)
############# OPENFRAMEWORKS ####
elif(splitAddress[1]=="of"):
separator="/"
splitAddress.remove("of")
finalAddress = separator.join(splitAddress)
oscmsg = OSCMessage()
oscmsg.setAddress(finalAddress)
oscmsg.append(data)
client_of.send(oscmsg)
############ FORWARD TO NODEJS ###
else :
oscmsg = OSCMessage()
oscmsg.setAddress(oscAddress)
oscmsg.append(data)
client_nodejs.send(oscmsg)
def sendMessage():
#value = 0.1
#values = arduino.readline()
try:
value = arduino.readline()
print value
#print struct.unpack("<L", value)[0]
#print isinstance(value, chr)
#intvalue = ord(value)
msg = OSCMessage()
msg.setAddress('/oscTest')
msg.append(float(value))
except:
print "lo saltiamo"
pass
#print value
try:
client.send(msg)
except:
print "Waiting for SuperCollider to become available..."
pass
timedSendMessage() # recursive call, keeps the timer going
def updateNode(self,args,BSSID,kind):
if BSSID == " ":
return
msg = OSCMessage("/update")
msg.append(kind.strip())
msg.append(args)
msg.append(BSSID.strip())
self.client.send(msg)
def processObjectVector( self, objectVector):
# Function to be implemented by all derived MetaDataProcessor interfaces.
# print( "ChangeVolumeProcessor::processObjectVector() called." )
objVectorNew = deepcopy(objectVector)
objIndex = 0
if type(objVectorNew) is list:
for obj in objVectorNew:
if self.active:
if int( obj['id']) in self.objectId:
#objID = int(obj['id']) + 1
objIndex = objIndex + 1
if obj['type'] == 'plane':
az = float(obj['direction']['az'])
el = float(obj['direction']['el'])
r = float(obj['direction']['refdist'])
#radius set to 1 atm
#SPAT_msg = "source " + str(objID) + " aed " + str(-az) + " " + str(el) + " " + str(1)
#SPAT_SOCK.sendto(SPAT_msg, (SPAT_IP, SPAT_PORT))
SPAT_osc = OSCMessage()
SPAT_osc.setAddress('/SPAT/pos')
SPAT_osc.append([objIndex, -az, el, 1])
client.send(SPAT_osc)
#print "hi"
else:
x = float(obj[ 'position' ]['x'])
y = float(obj[ 'position' ]['y'])
z = float(obj[ 'position' ]['z'])
(r,az,el) = cart2sphDeg(x,y,z)
#SPAT_msg = "source " + str(objID) + " aed " + str(-az) + " " + str(el) + " " + str(1)
#SPAT_SOCK.sendto(SPAT_msg, (SPAT_IP, SPAT_PORT))
SPAT_osc = OSCMessage()
SPAT_osc.setAddress('/SPAT/pos')
SPAT_osc.append([objIndex, -az, el, 1])
client.send(SPAT_osc)
#print "hi"
return objVectorNew
def loop():
global messageQ, clientMap, oscOut, currentButtonState, lastDownTime, isRecording, audioThread
## deal with UI
previousButtonState = currentButtonState
currentButtonState = GPIO.input(SWITCH_PIN)
buttonJustGotPressed = (currentButtonState is GPIO.HIGH
and previousButtonState is GPIO.LOW)
buttonJustGotReleased = (currentButtonState is GPIO.LOW
and previousButtonState is GPIO.HIGH)
if buttonJustGotPressed:
lastDownTime = time()
if (isRecording):
if ((time() - lastDownTime > 8.0)
or (buttonJustGotReleased and (time() - lastDownTime > 1.0))
or buttonJustGotPressed):
isRecording = False
GPIO.output(LED_PIN, GPIO.LOW)
audioThread.join()
call('rm -rf vox.mp3', shell=True)
call('lame -mm -r vox.raw vox.mp3', shell=True)
call('cp vox.mp3 data/vox_' +
strftime("%Y%m%d_%H%M%S", localtime()) + '.mp3',
shell=True)
call('rm -rf vox.raw', shell=True)
_setupAudio()
messageQ.put((1, VOICE_MESSAGE_STRING))
elif buttonJustGotPressed:
isRecording = (not audioInput is None)
GPIO.output(LED_PIN, GPIO.HIGH)
audioThread = RecordThread()
audioThread.start()
## deal with messages
if (not messageQ.empty()):
# TODO change this to something more complicated...
# TODO nltk
msg = messageQ.get()[1]
for index, (i, p) in enumerate(clientMap):
if (time() - clientMap[(i, p)] < 60):
oscMsg = OSCMessage()
oscMsg.setAddress("/ffqmevox")
oscMsg.append(msg.encode('utf-8'))
## TODO: pan and tilt and delay
oscMsg.append(randint(0, 255))
oscMsg.append(randint(0, 255))
oscMsg.append(0 if random() < 0.66 else index *
len(msg.encode('utf-8')) * 200)
try:
oscOut.connect((i, p))
oscOut.sendto(oscMsg, (i, p))
oscOut.connect((i, p))
except OSCClientError:
print "no connection to %s : %s, can't send message" % (i,
p)
def send_value(self):
for add, d in self.neighbors.items():
c = OSCClient()
c.connect(("localhost", add))
msg = OSCMessage("/receive")
msg.append(self._address)
msg.append(self.data["value"])
msg.append(self.data["iter"])
c.send(msg)
c.close()
def knob(self,arrCmd):
if arrCmd[0].lower() == "send":
oscm = OSCMessage("/live/return/device/param" )
arrCmd.pop(0)
else:
oscm = OSCMessage("/live/track/device/param" )
oscm.append(self.int_or_string(arrCmd[0])) #track
oscm.append(self.int_or_string(arrCmd[1])) #device
oscm.append(self.int_or_string(arrCmd[2])) #param
oscm.append(float(arrCmd[3]),'f') #value
return oscm
def send(self,arrCmd):
oscm = OSCMessage("/live/track/send" )
oscm.append(self.int_or_string(arrCmd[0]))
try:
arrCmd[1] = int(arrCmd[1])
arrCmd[1] += 1 #keep it 1 based instead of 0 based counting for consistancy
except:
arrCmd[1] = ord(arrCmd[1][0].lower()) - 97 #if using letters instead of numbers, convert to lower case and subtract so 'a' = 0, 'b' = 1, etc..
oscm.append(int(arrCmd[1]),'i')
oscm.append(int(arrCmd[2]) / 100.0,'f')
return oscm
def send_names(self, data):
if self.need_send_names:
self.need_send_names = False
msg = OSCMessage("/wekinator/control/setInputNames")
for k, v in data.items():
if k.endswith("flag"):
msg.append(k)
else:
msg.append(k + "_x")
msg.append(k + "_y")
msg.append(k + "_z")
self._send(msg)
def oscSend():
oscrot1 = OSCMessage()
oscrot1.setAddress("/engine/RPM")
oscrot1.append(measuredItemsValue[0])
OSCC.send(oscrot1)
oscrot2 = OSCMessage()
oscrot2.setAddress("/engine/OilPress")
oscrot2.append(measuredItemsValue[1])
OSCC.send(oscrot2)
oscrot3 = OSCMessage()
oscrot3.setAddress("/engine/OilTemp")
oscrot3.append(measuredItemsValue[2])
OSCC.send(oscrot3)
oscrot4 = OSCMessage()
oscrot4.setAddress("/engine/EGT")
oscrot4.append(measuredItemsValue[3])
OSCC.send(oscrot4)
def NewData(data):
global osc_client
# print("data: {}".format(data))
# simple example for on channel
# value = data[0] / 255
# # print("value: {}".format(value))
# # python-osc
# # osc_client.send_message("/filter", value)
# # pyOSC
# oscmsg = OSCMessage()
# oscmsg.setAddress("/1/fader1")
# oscmsg.append(value)
# osc_client.send(oscmsg)
# more complex example with multiple channels:
# dmxch - function
# 0 - ch 01 mix fader
# 1 - ch 01 mix on (mute)
# first check that data has all needed information.
if len(data) >= 1:
# all infos available
# set channel 01 fader
# ch/01/mix/fader/ [0.0,1.0] fader(1024)"
# convert channel level from 0..255 to 0..1
ch_value = data[0] / 255
oscmsg = OSCMessage()
oscmsg.setAddress("ch/01/mix/fader")
oscmsg.append(ch_value)
osc_client.send(oscmsg)
print(oscmsg)
if len(data) >= 2:
# all infos available
# set channel 01 mute
oscmsg = OSCMessage()
oscmsg.setAddress("ch/01/mix/on")
if data[1] is 0:
# channel active
oscmsg.append(1)
osc_client.send(oscmsg)
print(oscmsg)
elif data[1] is 255:
# channel off
oscmsg.append(0)
osc_client.send(oscmsg)
print(oscmsg)
def sendosc(oscaddress,oscargs):
#def sendosc(oscargs):
# also works : osclient.send(OSCMessage("/led", oscargs))
oscpath = oscaddress.split("/")
pathlength = len(oscpath)
oscmsg = OSCMessage()
#print "here in sendosc in nozosc"
#print oscaddress
#print oscargs
#raw_input("Press Enter to continue3...")
if oscpath[2] == "name":
print "we are asked to send a name"
oscmsg.setAddress(oscaddress)
oscmsg.append(oscargs)
if oscpath[2] == "status":
print "we are asked to send a status"
oscmsg.setAddress(oscaddress)
oscmsg.append(oscargs)
if oscpath[2] == "knob":
print "we are asked to send knob %d's value" % int(oscargs[0:3])
oscmsg.setAddress(''.join((oscaddress,"/",str(int(oscargs[0:3])))))
oscmsg.append(int(oscargs[3:100]))
if oscpath[2] == "osc":
#print "we are asked to send continusouly an osc value"
#print oscargs
oscmsg.setAddress(''.join((oscaddress,"/",str(int(oscargs[0:3])))))
#print "oscmsg:", oscmsg
oscmsg.append(int(oscargs[3:100]))
if oscpath[2] == "lfo":
#print "we are asked to send continusouly a lfo value"
oscmsg.setAddress(''.join((oscaddress,"/",str(int(oscargs[0:2])))))
oscmsg.append(int(oscargs[2:100]))
if oscpath[2] == "vco":
#print "we are asked to send continusouly a vco value"
oscmsg.setAddress(''.join((oscaddress,"/",str(int(oscargs[0:2])))))
oscmsg.append(int(oscargs[2:100]))
if oscpath[2] == "mix":
#print "we are asked to send continusouly a mix value"
oscmsg.setAddress(''.join((oscaddress,"/",str(int(oscargs[0:2])))))
oscmsg.append(int(oscargs[2:100]))
if oscpath[2] == "X":
print "we are asked to send continusouly a X value"
oscmsg.setAddress(oscaddress)
oscmsg.append(oscargs)
if oscpath[2] == "Y":
print "we are asked to send continusouly a Y value"
print "oscaddress:",oscaddress
print "oscargs",oscargs
oscmsg.setAddress(oscaddress)
oscmsg.append(oscargs)
if oscpath[2] == "offset":
print "we are asked to offset a curve"
oscmsg.setAddress(oscaddress)
oscmsg.append(oscargs)
if oscpath[2] == "color":
print "we are asked to change lazer color"
oscmsg.setAddress(oscaddress)
if len(oscargs) > 0:
oscmsg.append(oscargs)
try:
#print oscmsg
osclient.sendto(oscmsg, (oscIPout, oscPORTout))
oscmsg.clearData()
except:
print ('Connection refused at ',oscIPout)
pass
def quick_message(host, port, path, *args):
msg = OSCMessage(path)
[msg.append(d) for d in args]
client = OSCClient()
client.sendto(msg, (host, port), timeout=0)
def grid_key(self, x, y, s):
msg = OSCMessage("%s/grid/key" % self.prefix)
msg.append(x)
msg.append(y)
msg.append(s)
self.client.sendto(msg, (self.app_host, self.app_port), timeout=0)
#!/usr/bin/env python
# http://shinybit.github.io/sending-osc-messages-from-pythonista/
# https://gist.github.com/shinybit/3d7e0fc7e62887ab48e931af1d4c0986
# Get pyOSC here: https://trac.v2.nl/wiki/pyOSC
# The GitHub-hosted version of pyOSC is for Python 3 which isn't supported by Pythonista at the moment
from OSC import OSCClient, OSCMessage
client = OSCClient()
client.connect(("192.168.43.120", 8000))
msg = OSCMessage("/msg/notes")
msg.append([50, 60])
client.send(msg)
msg.clearData()
msg.append(["C3", 127])
client.send(msg)
client.send(OSCMessage("/quit"))
