def send_dmx():
ser.write(DMX_OPEN + DMX_INTENSITY + (''.join(dmx_data)) + DMX_CLOSE)
def osc_handler(addr, tags, data, client_address):
offset = 0
if addr.endswith('g'):
offset = 1
elif addr.endswith('b'):
offset = 2
elif addr.endswith('w'):
offset = 3
set_dmx(((int(addr[7]) - 1) * 4) + 1 + offset, data[0])
send_dmx()
DMX_OPEN = chr(126)
DMX_CLOSE = chr(231)
DMX_INTENSITY = chr(6) + chr(1) + chr(2)
DMX_INIT1 = chr(03) + chr(02) + chr(0) + chr(0) + chr(0)
DMX_INIT2 = chr(10) + chr(02) + chr(0) + chr(0) + chr(0)
ser = serial.Serial('/dev/tty.usbserial-ENYXTI9L')
ser.write(DMX_OPEN + DMX_INIT1 + DMX_CLOSE)
ser.write(DMX_OPEN + DMX_INIT2 + DMX_CLOSE)
dmx_data = [chr(0)] * 513
osc_server = OSC.OSCServer(('localhost', 9999))
osc_server.addMsgHandler('default', osc_handler)
osc_server.serve_forever()
port=config.getint('redis', 'port'),
db=0)
response = r.client_list()
except redis.ConnectionError:
print "Error: cannot connect to redis server"
exit()
# combine the patching from the configuration file and Redis
patch = EEGsynth.patch(config, r)
del config
# this determines how much debugging information gets printed
debug = patch.getint('general', 'debug')
try:
s = OSC.OSCServer(
(patch.getstring('osc', 'address'), patch.getint('osc', 'port')))
if debug > 0:
print "Started OSC server"
except:
print "Unexpected error:", sys.exc_info()[0]
print "Error: cannot start OSC server"
exit()
# this is a list of OSC messages that are to be processed as button presses, i.e. using a pubsub message in redis
button_list = patch.getstring('button', 'push', multiple=True)
# the scale and offset are used to map OSC values to Redis values
scale = patch.getfloat('output', 'scale', default=1)
offset = patch.getfloat('output', 'offset', default=0)
# the results will be written to redis as "osc.1.faderA" etc.
# TO SEND OSC MESSAGES TO MACHINES
oscClients = []
for i in range(len(machinesIP)) :
client = OSC.OSCClient()
client.connect( (machinesIP[i],milluminListenPort) )
oscClients.append(client)
# TO RECEIVE OSC MESSAGES (from TouchOSC for example)
oscServer = OSC.OSCServer( ('0.0.0.0',senderPort) )
def message_handler(addr, tags, stuff, source):
# ECHO MESSAGE TO MACHINES
msg = OSC.OSCMessage()
msg.setAddress(addr)
msg.append(stuff)
for i in range(len(machinesIP)) :
oscClients[i].send(msg)
# PRINT MESSAGE
if printMessage :
print "---"
print "received new osc msg from %s" % OSC.getUrlStr(source)
print "with addr : %s" % addr
#telepot.api._pools = {
# 'default': urllib3.PoolManager(num_pools=3, maxsize=10, retries=6, timeout=30),
#}
auth = configure.TG_TOKEN
masterId = configure.TG_MASTER_ID
bot = telepot.Bot(auth)
mqtt_client = mqtt.Client(configure.MOSQUITTO_USER_NAME + '/000')
mqtt_client.username_pw_set(username=configure.MOSQUITTO_USER_NAME,
password=configure.MOSQUITTO_PASSWORD)
#mqtt_client.connect_async(host=configure.MOSQUITTO_IP, port=configure.MOSQUITTO_PORT, keepalive=60)
mqtt_client.connect(host=configure.MOSQUITTO_IP,
port=configure.MOSQUITTO_PORT,
keepalive=60)
osc_server = OSC.OSCServer(configure.OSC_SERVER)
osc_client = []
oled_new_message = False
oled_new_message_prev = oled_new_message
oled_msg = ['', '']
#sched = BackgroundScheduler(daemon=True)
sched = BackgroundScheduler()
sched_day_of_week = configure.SCHEDULED_TIME[
0] # 0-6 mon,tue,wed,thu,fri,sat,sun
sched_hour = configure.SCHEDULED_TIME[1] # 0-23
sched_minute = configure.SCHEDULED_TIME[2] # 0-59
#configure.printConf()
uarm1.set_position(0, 0, 0)
uarm1.set_wrist(90)
sleep(2)
except:
print "Uarm 1 Not Available"
try:
uarm2 = pyuarm.UArm(debug=False, port_name='/dev/cu.usbserial-AI04I16Q')
uarm2.set_position(0, 0, 0)
uarm2.set_wrist(90)
sleep(2)
except:
print "Uarm 2 Not Available"
server = OSC.OSCServer(("127.0.0.1", 5005))
server.addDefaultHandlers()
#Cartesian variables
#X: -300-300
#Y: 50 - 330
#Z: -150-250 ideal 100
x1 = 0
y1 = 0
z1 = 0
x2 = 0
y2 = 0
z2 = 0
from subprocess import call
# ==== CAMERA SECTION ==== #
def getImagePath(): # new
return datetime.datetime.now().strftime(
"/home/pi/lfimages/%Y-%m-%d_%H.%M.%S")
# ==== OSC SECTION ==== #
# tupple with ip the OSC server will listen to.
receive_address = '192.168.42.1', 9000
# OSC Server. there are three different types of server.
server = OSC.OSCServer(receive_address) # basic
##s = OSC.ThreadingOSCServer(receive_address) # threading
##s = OSC.ForkingOSCServer(receive_address) # forking
# this registers a 'default' handler (for unmatched messages),
# an /'error' handler, an '/info' handler.
# And, if the client supports it, a '/subscribe' & '/unsubscribe' handler
server.addDefaultHandlers()
stopped = False
fastCamStarted = False
def start_camd():
outpath = getImagePath()
if not os.path.exists(outpath):
print('--------------------')
print("-- OSC LISTENER -- ")
print('--------------------')
print("IP:", args.ip)
print("PORT:", args.port)
print("ADDRESS:", args.address)
print('--------------------')
print("%s option selected" % args.option)
# connect server
server = osc_server.ThreadingOSCUDPServer((args.ip, args.port),
dispatcher)
server.serve_forever()
elif sys.version_info.major == 2:
s = OSC.OSCServer(
(args.ip, args.port)) # listen on localhost, port 57120
if args.option == "print":
s.addMsgHandler(args.address, print_message)
elif args.option == "record":
i = 0
while os.path.exists("osc_test%s.txt" % i):
i += 1
filename = "osc_test%i.txt" % i
textfile = open(filename, "w")
textfile.write("time,address,messages\n")
textfile.write("-------------------------\n")
print("Recording to %s" % filename)
signal.signal(signal.SIGINT, close_file)
# Display server attributes
print('--------------------')
print("-- OSC LISTENER -- ")
LED_FREQ_HZ = 800000 # LED signal frequency in hertz (usually 800khz)
LED_DMA = 5 # DMA channel to use for generating signal (try 5)
LED_BRIGHTNESS = 255 # Set to 0 for darkest and 255 for brightest
LED_INVERT = False # True to invert the signal (when using NPN transistor level shift)
LED_CHANNEL = 0 # set to '1' for GPIOs 13, 19, 41, 45 or 53
LED_STRIP = ws.WS2811_STRIP_GRB # Strip type and colour ordering
strip1 = Adafruit_NeoPixel(LED_COUNT, LED_PIN1, LED_FREQ_HZ, LED_DMA, LED_INVERT, LED_BRIGHTNESS, 0, LED_STRIP)
strip2 = Adafruit_NeoPixel(LED_COUNT, LED_PIN2, LED_FREQ_HZ, LED_DMA, LED_INVERT, LED_BRIGHTNESS, 1, LED_STRIP)
strip1.begin()
strip2.begin()
c = OSC.OSCServer(('192.168.0.111', 4000))
c.addDefaultHandlers()
def printing_handler(addr, tags, stuff, source):
print "---"
print "received new osc msg from %s" % OSC.getUrlStr(source)
print "with addr : %s" % addr
print "typetags %s" % tags
print "data %s" % stuff
print "---"
#leds = stuff[0].encode('string-escape').split('\\x')
#print leds
sleep(2)
LED_DMA = 5 # DMA channel to use for generating signal (try 5)
LED_BRIGHTNESS = 255 # Set to 0 for darkest and 255 for brightest
LED_INVERT = False # True to invert the signal (when using NPN transistor level shift)
LED_CHANNEL = 0 # set to '1' for GPIOs 13, 19, 41, 45 or 53
LED_STRIP = ws.WS2811_STRIP_GRB # Strip type and colour ordering
strip1 = Adafruit_NeoPixel(LED_COUNT, LED_PIN1, LED_FREQ_HZ, LED_DMA,
LED_INVERT, LED_BRIGHTNESS, 0, LED_STRIP)
strip2 = Adafruit_NeoPixel(LED_COUNT, LED_PIN2, LED_FREQ_HZ, LED_DMA,
LED_INVERT, LED_BRIGHTNESS, 1, LED_STRIP)
strip1.begin()
strip2.begin()
#setup id address of computer - i guess this is the raspi IP
c = OSC.OSCServer(('0.0.0.0', 4000)) #address must be formatted as a tuple
c.addDefaultHandlers()
def printing_handler(addr, tags, stuff, source):
print "---"
print "received new osc msg from %s" % OSC.getUrlStr(source)
print "with addr : %s" % addr
print "typetags %s" % tags
print "data %s" % stuff
print "---"
#leds = stuff[0].encode('string-escape').split('\\x')
#print leds
sleep(2)
# The following are global variables, used by threads
#tempo lower is faster! default 1.5
timeScale = 1.5
# get data
midiList = formMidiList()
zerotime = time()
mytime = 0.0
client = OSC.OSCClient()
send_address = '127.0.0.1', 9002
recieve_address = '127.0.0.1', 9001
client.connect(send_address)
s = OSC.OSCServer(recieve_address)
s.addDefaultHandlers()
midiEvents = midiList.events
def timehandler(addr, tags, stuff, source):
#global timeScale
timeScale = stuff[0] #change tempo
print timeScale
s.addMsgHandler("/tempo", timehandler)
st = threading.Thread(target=s.serve_forever)
st.start()
import tensorflow as tf
import magenta
from magenta.models.melody_rnn import melody_rnn_model
from magenta.models.melody_rnn import melody_rnn_generate
from magenta.models.melody_rnn import melody_rnn_sequence_generator
from magenta.protobuf import generator_pb2
importlib.import_module('ascii_arts')
import ascii_arts
# Global Variables
# Addresses and ports to communicate with SuperCollider.
receive_address = ('127.0.0.1', 12345)
send_address = ('127.0.0.1', 57120)
server = OSC.OSCServer(receive_address) # To receive from SuperCollider.
client = OSC.OSCClient() # To send to SuperCollier.
client.connect(send_address)
mode = 'psc' # Current mode of operation: {'psc', 'robot', 'improv'}
# Robot improv specific variables.
min_primer_length = 20
max_robot_length = 20
accumulated_primer_melody = []
generated_melody = []
# Mapping of notes (defaults to identity).
note_mapping = {i: i for i in range(21, 109)}
improv_mode = '2sounds' # Either '2sounds', '1sound', 'question'.
improv_status = 'psc' # One of 'psc' or 'robot'.
# Read in the PerformanceRNN model.
and len(betas) == numValuesToRead
and len(gammas) == numValuesToRead):
d = datetime.utcnow()
unixtime = calendar.timegm(d.utctimetuple())
###save env.unwrapped.totalStates and env.unwrapped.actions as: [state,action] pairs
with open('muse_baseline_measurement_' + str(unixtime) + '.csv',
'wb') as f:
writer = csv.writer(f)
writer.writerows([
deltas[1:numValuesToRead], thetas[1:numValuesToRead],
alphas[1:numValuesToRead], betas[1:numValuesToRead],
gammas[1:numValuesToRead]
])
print "Done writing out measurements to a csv file..."
s.server_close()
try:
if __name__ == "__main__":
s = OSC.OSCServer(
('127.0.0.1', 4445)) # listen on localhost, port 57120
s.addMsgHandler("default", _default_handler)
s.addMsgHandler('/muse/elements/delta_relative', _handler)
s.addMsgHandler('/muse/elements/theta_relative', _handler)
s.addMsgHandler('/muse/elements/alpha_relative', _handler)
s.addMsgHandler('/muse/elements/beta_relative', _handler)
s.addMsgHandler('/muse/elements/gamma_relative', _handler)
s.serve_forever()
except Exception:
print "Interrupted the server after writing to a csv file"
'type': type,
'device': device,
'cable': "left",
'offsetX': 0,
'offsetY': 0,
'tiltmode': 0,
'grids': 0
}
if debugMode == 1:
print deviceInfo
devices.insert(i, deviceInfo)
clearHandler(prefix, 'i', (0, ), 0)
thread = MonomeThread(deviceInfo, oscClient)
thread.start()
deviceInfo['thread'] = thread
devices = []
oscServer = OSC.OSCServer(listenAddr)
oscServer.addMsgHandler("/sys/prefix", prefixHandler)
oscServer.addMsgHandler("/sys/cable", cableHandler)
oscServer.addMsgHandler("/sys/offset", offsetHandler)
oscServer.addMsgHandler("/sys/intensity", intensityHandler)
oscServer.addMsgHandler("/sys/report", reportHandler)
oscServer.addMsgHandler("/sys/test", testHandler)
oscServer.addMsgHandler("/sys/grids", gridsHandler)
oscClient = OSC.OSCClient()
oscClient.connect(sendAddr)
init()
st = threading.Thread(target=oscServer.serve_forever)
st.start()
class PiException(Exception):
def __init__(self, value):
self.value = value
def __str__(self):
return repr(self.value)
##########################
# OSC
##########################
# Initialize the OSC server and the client.
print receive_address
s = OSC.OSCServer(receive_address)
s2 = OSC.OSCServer(receive_addresslocal)
c = OSC.OSCClient()
c.connect(send_address)
s.addDefaultHandlers()
# /data noise centroid bpm
def getFiles(add, type, data, sender):
if debug:
print "recieved : " + key + " : " + mode
global key
global mode
global bpm
import OSC
import time, threading
import sys
from keyedmarkov import KeyedMarkovEmitter
try:
listen_on_address = ('127.0.0.1', int(sys.argv[1]))
send_to_address = ('127.0.0.1', int(sys.argv[2]))
except IndexError, ValueError:
print "Usage: python markov_server.py [port to listen on] [port to send to] [...keys to use for merkov emitter]"
exit()
osc_server = OSC.OSCServer(listen_on_address)
osc_server.addDefaultHandlers()
osc_client = OSC.OSCClient()
osc_client.connect(send_to_address)
emitter = KeyedMarkovEmitter()
emitter.setup(16, sys.argv[3:], 2000)
def log_request(id, addr, tags, stuff, source):
print "--- Data received [" + str(id) + "]: (" + str(
OSC.getUrlStr(source)) + " : " + str(addr) + ")"
print "--- Typetags: [%s]" % tags
print "--- Data: %s" % stuff
print ""
def train_system(received_data, delimiter=":"):
import time, threading
import OSC
server_address = ("172.16.65.62", 7000)
server = OSC.OSCServer(server_address)
server.addDefaultHandlers()
def myMsgPrinter_handler(addr, tags, data, client_address):
print "osc://%server%server ->" % (OSC.getUrlStr(client_address), addr),
print "(tags, data): (%server, %server)" % (tags, data)
server.addMsgHandler("/fotn/start", myMsgPrinter_handler)
server.addMsgHandler("/fotn/end", myMsgPrinter_handler)
server.addMsgHandler("/fotn/matrix", myMsgPrinter_handler)
server.addMsgHandler("/fotn/jis", myMsgPrinter_handler)
server.addMsgHandler("/fotn/utf", myMsgPrinter_handler)
server.addMsgHandler("/fotn/start", myMsgPrinter_handler)
server_thread = threading.Thread(target=server.serve_forever)
server_thread.start()
# this determines how much debugging information gets printed
debug = config.getint('general', 'debug')
try:
r = redis.StrictRedis(host=config.get('redis', 'hostname'),
port=config.getint('redis', 'port'),
db=0)
response = r.client_list()
if debug > 0:
print "Started OSC server"
except redis.ConnectionError:
print "Error: cannot connect to redis server"
exit()
try:
s = OSC.OSCServer((config.get('osc',
'hostname'), config.getint('osc', 'port')))
if debug > 0:
print "Started OSC server"
except:
print "Unexpected error:", sys.exc_info()[0]
print "Error: cannot start OSC server"
exit()
# this is a list of OSC messages that are to be processed as button presses, i.e. using a pubsub message in redis
button_list = config.get('button', 'push').split(',')
# define a message-handler function for the server to call.
def forward_handler(addr, tags, data, source):
print "---"
print "source %s" % OSC.getUrlStr(source)
def setup(self):
print "[PY] client init"
self.c = OSC.OSCClient()
self.c.connect(SEND_ADDRESS)
msg = OSC.OSCMessage()
msg.setAddress("/status")
msg.append("python OSC started")
self.c.send(msg)
print "[PY] server init"
self.s = OSC.OSCServer(RECV_ADDRESS)
self.s.addDefaultHandlers()
#self.s.addMsgHandler("/bapabar/test", printing_handler)
self.s.addMsgHandler("/image/saved", self.imageSaved)
self.s.addMsgHandler("/cam/kick", self.camKick)
self.s.addMsgHandler("/test", self.printMsg)
self.s.addMsgHandler("/kill", self.kill)
self.st = threading.Thread(target=self.s.serve_forever)
self.st.start()
print "[PY] server py2py test"
self.c2 = OSC.OSCClient()
self.c2.connect(RECV_ADDRESS)
msg = OSC.OSCMessage()
msg.setAddress("/test")
msg.append(1)
self.c2.send(msg)
try:
print "[PY] intel camera setup"
self.pipeline = rs.pipeline()
self.config = rs.config()
self.config.enable_stream(rs.stream.depth, 1280, 720,
rs.format.z16, 30)
self.config.enable_stream(rs.stream.color, 1280, 720,
rs.format.bgr8, 30)
self.pipeline.start(self.config)
except:
print "[PY] intel camera setup error"
msg = OSC.OSCMessage()
msg.setAddress("/kill")
msg.append(1)
self.c2.send(msg)
return
print "[PY] intel camera setup done"
try:
msg = OSC.OSCMessage()
msg.setAddress("/cam/start")
self.c.send(msg)
except:
print "[PY] error (need to setup oF server)"
msg = OSC.OSCMessage()
msg.setAddress("/kill")
msg.append(1)
self.c2.send(msg)
if 0: #finish in 4 sec
time.sleep(4)
print "[PY] server py2py test"
self.c2 = OSC.OSCClient()
self.c2.connect(RECV_ADDRESS)
msg = OSC.OSCMessage()
msg.setAddress("/kill")
msg.append(1)
self.c2.send(msg)
return
import OSC
import time, random, threading
# TO SEND OSC MESSAGES
oscClient = OSC.OSCClient()
oscClient.connect(('127.0.0.1', 5000))
# TO RECEIVE OSC MESSAGES
oscServer = OSC.OSCServer(('127.0.0.1', 5001))
def printing_handler(addr, tags, stuff, source):
print "---"
print "received new osc msg from %s" % OSC.getUrlStr(source)
print "with addr : %s" % addr
print "typetags %s" % tags
print "data %s" % stuff
print "---"
oscServer.addMsgHandler("/millumin/selectedLayer/opacity", printing_handler)
oscServer.addMsgHandler("/millumin/index:1/opacity", printing_handler)
st = threading.Thread(target=oscServer.serve_forever)
st.start()
# TEST 1 : SENDING OSC BUNDLE
bundle = OSC.OSCBundle()
msg = OSC.OSCMessage()
msg.setAddress("/millumin/selectedLayer/opacity")
msg.append(80)
import OSC
import time
def handler(addr, tags, data, client_address):
txt = "OSCMessage '%s' from %s: " % (addr, client_address)
txt += str(data)
print(txt)
if __name__ == "__main__":
s = OSC.OSCServer(
('192.168.2.101', 12289)) # listen on localhost, port 57120
s.addMsgHandler(
'/magic_hat', handler
) # call handler() for OSC messages received with the /startup address
s.addMsgHandler('/bird_cage', handler)
s.addMsgHandler('/black_board', handler)
s.serve_forever()
# c = OSC.OSCClient()
# c.connect(('192.168.2.9',12211))
# try:
# while True:
# print "send"
# oscmsg = OSC.OSCMessage()
# oscmsg.setAddress("/endup")
# oscmsg.append('HELLO')
# c.send(oscmsg)
while True:
if cfg.act == 0:
time.sleep(1)
cfg.timedAct = 0
timerThread = threading.Thread(target=timer)
timerThread.start()
##################
# #
# OSC #
# #
##################
server = OSC.OSCServer(cfg.receive_address)
server.addDefaultHandlers
server.addMsgHandler("/fft", change_fft)
server.addMsgHandler("/waveform", change_waveform)
oscServer = threading.Thread(target=server.serve_forever)
oscServer.start()
####################
# #
# starting display #
# #
####################
cfg.readPatchList()
# endereço e porta do servidor OSC (esse código)
END_SERV = '127.0.0.1'
PORTA_SERV = 9000
def trata(addr, tags, dados, origem):
m = "%s [%s] %s" % (addr, tags, str(dados))
#t="%s enviou: %s\n" % (osc.getUrlStr(origem), m)
t = str((osc.getUrlStr(origem), m))
print t
with open("log-golly.txt", "a") as f:
f.write(t)
s = osc.OSCServer((END_SERV, PORTA_SERV))
s.addDefaultHandlers()
s.addMsgHandler("/golly", trata)
st = threading.Thread(target=s.serve_forever)
st.start()
print "Servidor OSC inicializado. Use ctrl-C para sair."
# loop principal
try:
while True:
time.sleep(0.1)
except KeyboardInterrupt:
pass
s.close()
def controllerChange(addr, tags, data, client_address):
txt = "OSCMessage '%s' from %s: " % (addr, client_address)
txt += str(data)
print(txt)
channel_number = data[0]
control_number = data[1]
value_number = data[2]
msg = mido.Message('control_change',
channel=channel_number,
control=control_number,
value=value_number)
bmsg = msg.bytes()
smsg = bytearray(bmsg)
ser.write(smsg)
if __name__ == "__main__":
while (confirm == 0):
try:
s = OSC.OSCServer(('192.168.0.108', port))
s.addMsgHandler('/', noteOn)
s.addMsgHandler('/nOff', noteOff)
s.addMsgHandler('/cchange', controllerChange)
s.serve_forever()
print("Port number set to" + str(port))
confirm = 1
except socket.error, exc:
print("Caught exception socket.error: %s" % exc)
port = port + 1
print("Port number now set to " + str(port))
def OSC_init():
OSCrec = OSC.OSCServer(("0.0.0.0", 8000))
OSCrec.timeout = 0.05
OSCrec.addMsgHandler("/status", user_callback)
_thread.start_new_thread(OSCrec.serve_forever, ())
def __init__(self, attract):
self.position = MultiD([0]*NDIMS)
for dim in range(NDIMS):
self.position.x[dim] = random.randint(1, DIMLIMIT)
self.attraction = attract
def rand_update(self):
for dim in range(NDIMS):
self.position.x[dim] = random.randint(1, DIMLIMIT)
################################################################################
# RECEIVING OSC
s = OSC.OSCServer(RECEIVE_ADDRESS)
s.addDefaultHandlers()
def attractor_handler(addr, tags, stuff, source):
print "---"
print "Received new osc msg from %s" % OSC.getUrlStr(source)
print "With addr : %s" % addr
print "Typetags %s" % tags
global attractors
attractor = random.choice(attractors) #modify a random attractor
for item in stuff:
print "data %f" % item
# Assign dimension values
for i in range(NDIMS):
attractor.position.x[i] = int( min(max(stuff[i],0.0),1.0) * DIMLIMIT )
print "Dim %d val: %d" % (i,attractor.position.x[i])
count = 0
def handler(addr, tags, data, client_address):
txt = "OSCMessage '%s' from %s: " % (addr, client_address)
txt += str(data)
print(txt)
def countHandler(addr, tags, data, client_address):
global count
count += int(data[0])
print count
def default_handler(path, tags, args, source):
print "Path is: ", path, " Tags is: ", tags, " Args are: ", args, " Source is: ", source
s = OSC.OSCServer(('0.0.0.0', 5000)) # listen on localhost, port 57120
s.addMsgHandler(
'/startup', handler
) # call handler() for OSC messages received with the /startup address
s.addMsgHandler('/count', countHandler)
s.addMsgHandler("default", default_handler)
s.serve_forever()
while True:
time.sleep(1)
class PiException(Exception):
def __init__(self, value):
self.value = value
def __str__(self):
return repr(self.value)
##########################
# OSC
##########################
# Initialize the OSC server and the client.
s = OSC.OSCServer(receive_address)
s.addDefaultHandlers()
# adding serial interface with Arduino
arduino = serial.Serial('/dev/ttyACM1', 115200)
#booting pykeyboard
keyboard = PyKeyboard()
# Load the files
text = open("words.txt", "r").read().split()
# define a message-handler function for the server to call.
def test_handler(addr, tags, stuff, source):
print "---"
print "received new osc msg from %s" % OSC.getUrlStr(source)
print "with addr : %s" % addr
print "typetags %s" % tags
global prefix
global output_scale
global output_offset
monitor.debug("addr %s" % addr)
monitor.debug("data %s" % data)
# assume that it is a single scalar value
key = prefix + addr.replace('/', '.')
val = EEGsynth.rescale(data, slope=output_scale, offset=output_offset)
patch.setvalue(key, val)
try:
if sys.version_info < (3, 6):
s = OSC.OSCServer((osc_address, osc_port))
s.noCallback_handler = python2_message_handler
# s.addMsgHandler("/1/faderA", test_handler)
s.addDefaultHandlers()
# just checking which handlers we have added
monitor.info("Registered Callback functions are :")
for addr in s.getOSCAddressSpace():
monitor.info(addr)
# start the server thread
st = threading.Thread(target=s.serve_forever)
st.start()
else:
dispatcher = dispatcher.Dispatcher()
# dispatcher.map("/1/faderA", test_handler)
dispatcher.set_default_handler(python3_message_handler)
server = osc_server.ThreadingOSCUDPServer((osc_address, osc_port),
notes_file = datapath + 'notes.txt'
ch0_file = datapath + ch0 + '.dat'
ch1_file = datapath + ch1 + '.dat' #NI signal files
ch2_file = datapath + ch2 + '.dat'
ch3_file = datapath + ch3 + '.dat'
nx_file = datapath + 'nosex.dat'
ny_file = datapath + 'nosey.dat' #bonsai tracking files
hx_file = datapath + 'headx.dat'
hy_file = datapath + 'heady.dat'
cx_file = datapath + 'comx.dat'
cy_file = datapath + 'comy.dat'
ts_file = datapath + 'timestamp.dat'
receive_address = ('localhost', 6666)
trackingcoords = OSC.OSCServer(receive_address)
#bonsai tracking variables
qnosex = Queue.LifoQueue(0)
qnosey = Queue.LifoQueue(0)
#online position storage
nosex = np.zeros((1, 1))
nosey = np.zeros((1, 1))
headx = np.zeros((1, 1))
heady = np.zeros((1, 1))
comx = np.zeros((1, 1))
comy = np.zeros((1, 1))
ts = np.zeros((1, 1))
signaldata = np.zeros((channel_num, buffersize),
dtype=np.float64) #NI data collection reading variables
reader = AnalogMultiChannelReader(ni_data.in_stream)
def monitor(self,
product=None,
zmq_port=4000,
timeout=0.2,
full_trace=False,
console=True,
no_calibration=False,
calibration=None):
"""Listen to OSC messages on 3333.
Broadcast on the ZMQ PUB stream on the given TCP port."""
# get the product to use, either from the command line
# or from the environment variable, or use the default product
product = get_product(product=product)
self.product = product
self.monitor_enabled = console
self.osc_port = product["tuio_port"]
self.osc_ip = product["at_ip"]
self.zmq_port = zmq_port
self.timeout = timeout
self.full_trace = full_trace
self.last_exception = ""
# try to import calibration
# if not explicitly disabled with --no_calibration
self.min_latitude = -np.pi * 0.45
if not no_calibration:
try:
self.calibration = Calibration(calibration)
self.min_latitude = self.calibration.min_latitude
except (CalibrationException, OSError) as e:
print(e)
self.calibration = None
else:
self.calibration = None
# reset the timeouts
self.last_packet = wall_clock() # last time a packet came in
self.last_frame = wall_clock() # last time screen was redrawn
# create a ZMQ port to broadcast on
context = zmq.Context()
self.zmq_socket = context.socket(zmq.PUB)
self.zmq_socket.bind("tcp://*:%s" % zmq_port)
# listen for OSC events
self.msg = product["tuio_addr"]
self.osc_server = OSC.OSCServer((self.osc_ip, self.osc_port))
self.osc_server.addMsgHandler(self.msg, self._handler)
self.osc_server.timeout = timeout
# clear the touch status
self.last_fseq = -1
self.touch_list = {}
self.last_touch_list = {}
self.raw_list = {}
self.all_touches = {}
self.raws = {}
self.packet_trace = [] # short history of packet message strings
# launch the monitor
if self.monitor_enabled:
Screen.wrapper(self.monitor_loop)
else:
self.monitor_loop(False)
