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)