def start_osc_server(self): s = OSC.ThreadingOSCServer(('127.0.0.1', self.recv_port)) s.addDefaultHandlers() s.addMsgHandler('/monome/grid/led/set', self.osc_dispatch) t = threading.Thread(target=s.serve_forever) t.start() self.osc_client = s.client
def __init__(self, lpackHost, lpackPort, ledMap, oscHost, oscPort): """ установка начальных значений, создание OSC-сервера, назначение обработчиков, инициализация lightpack lpackHost, lpackPort - IP и порт хоста с Лайтпаком ledMap - массив для переопределения порядка светодиодов Лайтпака oscHost, oscPort - IP и порт на котором будет запущен OSC-сервер """ self.r = 127 self.g = 127 self.b = 127 self.smooth = 127 self.brightness = 0.5 self.ledMap = [[3,2,1],[4,-1,10],[5,-1,9],[6,7,8]] self.enabledLeds = Set([1,2,3,4,5,6,7,8,9,10]) self.gamma = 2 self.lpack = lightpack.lightpack(lpackHost, lpackPort, ledMap) self.lpack.connect() self.oscServer = OSC.ThreadingOSCServer((oscHost, oscPort)) self.oscServer.addDefaultHandlers() self.oscClient = OSC.OSCClient() self.profiles = self.lpack.getProfiles() self.currentProfileIndex = 0 self.mapControls() print "Registered Callback-functions are :" for addr in self.oscServer.getOSCAddressSpace(): print addr
def __init__(self, robotData): print "Create behavior manager with default behavior 'IdleState'" self.robotData = robotData self.lastTime = time.time() self.active = False self.thread = None self.currentState = BaseState() self.setState("IdleState") # setup server receive_address = '192.168.0.255', 8000 self.server = OSC.ThreadingOSCServer(receive_address) # setup handlers self.server.addMsgHandler("/IdleState", self.changeStateWithOSC) self.server.addMsgHandler("/BaseState", self.changeStateWithOSC) self.server.addMsgHandler("/ShakenState", self.changeStateWithOSC) self.server.addMsgHandler("/AngeredState", self.changeStateWithOSC) self.server.addMsgHandler("/BeingPetState", self.changeStateWithOSC) self.server.addMsgHandler("/ReturnToBaseState", self.changeStateWithOSC) self.server.addMsgHandler("/RemoveSnowState", self.changeStateWithOSC) self.server.addMsgHandler("/AttackBaseState", self.changeStateWithOSC) self.server.addMsgHandler("/DriveState", self.changeStateWithOSC) print "Serving on {}".format(self.server.server_address) self.server_thread = Thread(target=self.server.serve_forever) self.server_thread.start() print "done"
def main(args): addr = (args.addr, args.port) osc = OSC.ThreadingOSCServer(addr, bind_and_activate=False) # setup multicast osc.socket.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_LOOP, 1) osc.socket.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, 32) osc.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) osc.server_bind() mcast_iface_aton = socket.inet_aton(args.iface) osc.socket.setsockopt(socket.SOL_IP, socket.IP_MULTICAST_IF, mcast_iface_aton) mreq = socket.inet_aton(args.addr) + mcast_iface_aton osc.socket.setsockopt(socket.SOL_IP, socket.IP_ADD_MEMBERSHIP, mreq) osc.timeout = 0.1 if not args.no_curses: osc.handle_timeout = display_update else: global out_lock out_lock = threading.Lock() osc.server_activate() osc.addMsgHandler("default", handle_osc) osc.serve_forever()
def start_osc_server(self, port): s = OSC.ThreadingOSCServer(('localhost', port)) s.addDefaultHandlers() s.addMsgHandler('/monome/enc/key', self.osc_dispatch) s.addMsgHandler('/monome/enc/delta', self.osc_dispatch) t = threading.Thread(target=s.serve_forever) t.start()
def __init__(self, FAKE_CONNECTION=None): super(Anoto, self).__init__() if FAKE_CONNECTION is None: FAKE_CONNECTION = config.getboolean('Anoto Server', 'fake_connection') self.speed = TraceSpeed() self.keep_serving = True if not FAKE_CONNECTION: receive_address = (config.get('Anoto Server', 'receive_ip'), config.getint('Anoto Server', 'receive_port')) # self.osc_server = OSC.OSCServer(receive_address) # basic self.osc_server = OSC.ThreadingOSCServer(receive_address) else: receive_address = (config.get('Anoto Server', 'fake_receive_ip'), config.getint('Anoto Server', 'receive_port')) self.osc_server = OSC.ThreadingOSCServer(receive_address) # either way - print tracebacks self.osc_server.print_tracebacks = True
def __init__(self, ip, port): self.receive_address = ip, port self.s = OSC.ThreadingOSCServer(self.receive_address) self.s.addDefaultHandlers() # this registers a 'default' handler (for unmatched messages) self.st = threading.Thread(target=self.s.serve_forever) self.st.start() #Initialize variables self.curAddr = "No OSC address" self.curMess = "No OSC message" print "Starting OSCServer"
def __init__(self, ip, port): self.receive_address = (ip, port) self.s = OSC.ThreadingOSCServer(self.receive_address) self.s.addDefaultHandlers() # this registers a 'default' handler (for unmatched messages) self.st = threading.Thread(target=self.s.serve_forever) self.st.start() # Initialize variables self.curAddr = "No OSC address" # It can take the value of "movuino", "streamo", "gesture", "repetions" self.curMess = "No OSC message" print("Starting OSCServer")
def startServer(self, addr, port): self.addr = (addr, port) #home wifi #super(OSCInterface, self).__init__() self.threadedOSC = OSC.ThreadingOSCServer(self.addr) self.threadedOSC.addDefaultHandlers() self.threadedOSC.addMsgHandler("/1/play", self.play) self.threadedOSC.addMsgHandler("/1/record", self.record) self.threadedOSC.addMsgHandler("/1/skip", self.skip) self.threadedOSC.addMsgHandler("/1/keep", self.keep) self.threadedOSC.addMsgHandler("/1/delete", self.delete) self.threadedOSC.addMsgHandler("/1/threshold", self.threshold) self.threadedOSC.addMsgHandler("/1/stop", self.stop) self.st = threading.Thread(target=self.threadedOSC.serve_forever) self.st.start() print("Starting openOSC on addr and port: " + str(addr) + ":" + str(port))
def setup_osc_server(self, port=9002, address='localhost'): """ Sets OSC server to listening for messages from Pd. default port is 9002 on localhost. """ if address == 'localhost': address = '127.0.0.1' self.osc_server = OSC.ThreadingOSCServer((address, port)) self.osc_server.addDefaultHandlers() for ch in self.channel_list: self.osc_server.addMsgHandler('/%s' % ch, self._osc_server_handler) self.osc_thread = mp.Process(target=self.osc_server.serve_forever) # self.osc_thread = mp.Process(target = self._osc_server_serving) # self.osc_thread.setDaemon(True) self.osc_server_setup = True
def main(): signal.signal(signal.SIGINT, signal_handler) s = OSC.ThreadingOSCServer(("localhost", 5444)) # threading print "Creating OSCServer on port 5444..." s.addMsgHandler("/OSC", osc_handler) # adding our function st = Thread(target=s.serve_forever) st.start() tornado.options.parse_command_line() app = Application() app.listen(options.port) io_loop = tornado.ioloop.IOLoop.instance() tornado.ioloop.PeriodicCallback(OSCWebSocketHandler.update_coords, 10.0, io_loop=io_loop).start() io_loop.start()
def create_osc_server(ip, port): receive_address = (ip, port) server = OSC.ThreadingOSCServer(receive_address) server.addDefaultHandlers() # 'default' handler for unmatched messages server.addMsgHandler("/print", printing_handler) # useful for debugging return server
print "with addr : %s" % addr print "addr[-1] : %s" % mesothelioma print "typetags :%s" % tags print "the actual data is : %s" % data print "---" def sendOSCMsg(address='/print', data=[]): m = OSC.OSCMessage() m.setAdress(address) for d in data: m.append(d) client.send(m) serialOSC = OSC.ThreadingOSCServer(serReceive) pdOSC = OSC.ThreadingOSCServer(pdReceive) initOSCClient(localhost, sendSer) initOSCClient( localhost, sendPD, ) serialOSC.addMsgHandler("/test", printing_handler) pdOSC.addMsgHandler("/test", printing_handler) SOSC = threading.Thread(target=serialOSC.serve_forever) POSC = threading.Thread(target=pdOSC.serve_forever) SOSC.daemon = True
import OSC import threading import socket #------OSC Server-------------------------------------# # local maching running osc2udp.py script receive_address = '192.168.129.160', 57121 #UDP # windows machine running freepie and steamvr import socket UDP_IP = "192.168.129.201" UDP_PORT = 9999 # OSC Server. there are three different types of server. s = OSC.ThreadingOSCServer(receive_address) # this registers a 'default' handler (for unmatched messages) s.addDefaultHandlers() # define a message-handler function for the server to call. def printing_handler(addr, tags, value, source): if addr == '/muse/elements/theta_absolute': print "theta_absolute", '%.3f' % value[0] sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # UDP sock.sendto('%.3f' % value[0], (UDP_IP, UDP_PORT)) s.addMsgHandler("/muse/elements/theta_absolute", printing_handler)
from time import sleep from random import random import math import OSC from OSC import OSCServer import time, threading import sys sys.path.append("../") from ax12 import ax12 server = OSC.ThreadingOSCServer(("meme00.local", 8888)) def _oscHandler(addr, tags, stuff, source): addrTokens = addr.lstrip('/').split('/') if (addrTokens[0].lower() == "angles"): angles = [] for (i, v) in enumerate(stuff): ang = math.degrees(v) angInt = int(ang * 1024 / 300) angPos = 520 + angInt angPos = 820 if angPos > 820 else angPos angPos = 220 if angPos < 220 else angPos angles.append(angPos) angPos = angPos if (i + 1) % 2 == 0 else 1024 - angPos servos.moveSpeedRW(i + 1, angPos, 244) sleep(0.02) print angles servos.action() sleep(0.02) elif (addrTokens[0].lower() == "teste"):
def send_play(): msg = OSC.OSCMessage() msg.setAddress("/play") if v_play.get() == "Play": msg.append(1) c.send(msg) if v_play.get() == "Stop": msg.append(0) c.send(msg) # OSC SERVER # ========== s = OSC.ThreadingOSCServer(('localhost', 7111)) s.addDefaultHandlers() def receive_OSC(addr, tags, stuff, source): print addr, stuff[0] if addr == "/tempo": v_tempo.set(stuff[0]) if addr == "/density": v_density.set(stuff[0]) if addr == "/legato": v_legato.set(stuff[0]) if addr == "/saturation": v_saturation.set(stuff[0]) if addr == "/substitution": v_substitution.set(stuff[0])
def __init__(self, send_address, listen_address): super(OSCThread, self).__init__() self.stoprequest = threading.Event() self.s = OSC.ThreadingOSCServer(listen_address) self.objectID_lock = threading.Lock() self.activeObjects = set() self.new_object_listener = None self.removed_object_listener = None # Set Server to return errors as OSCMessages to "/error" self.s.setSrvErrorPrefix("/error") # Set Server to reply to server-info requests with OSCMessages to "/serverinfo" self.s.setSrvInfoPrefix("/serverinfo") # this registers a 'default' handler (for unmatched messages), # an /'error' handler, an '/info' handler. # And, if the client supports it, a '/subscribe' & '/unsubscribe' handler self.s.addDefaultHandlers() self.s.addMsgHandler("default", self.printing_handler) #s.addMsgHandler("/MM_Remote/Control/activeObjectsID", pallete_handler) self.s.addMsgHandler("/MM_Remote/Control/activeObjectsID", self.objectID_handler) self.s.addMsgHandler("/MM_Remote/Control/activeObjectsPosition", self.pallete_handler) self.s.addMsgHandler("/MM_Remote/Global/pairingAccepted", self.pairing_handler) print "Registered Callback-functions:" for addr in self.s.getOSCAddressSpace(): print addr print "\nStarting OSCServer. Use ctrl-C to quit." self.st = threading.Thread(target=self.s.serve_forever) self.st.start() self.c2 = OSC.OSCClient() self.c2.connect(send_address) #subreq = OSC.OSCMessage("/MashMachine/Control/getActiveObjectsPosition") tries = 10 self.paired = 0 try: while self.paired == 0 and tries > 0: try: print "Pairing..." subreq = OSC.OSCMessage("/MashMachine/Global/makePairing") subreq.append(listen_address[0]) subreq.append(listen_address[1]) self.c2.send(subreq) except (OSC.OSCClientError): print "Pairing or Subscribing failed.." time.sleep(1) tries -= 1 except (KeyboardInterrupt): print "Continue without pairing.." self.paired = 2 if (tries == 0): print "Continue without pairing.." self.paired = 2
def quitpd(addr, tags, data, source): sendOSCPD("/quitpd",1) def enc(addr, tags, data, source): return 0 def encbutton(addr, tags, data, source): return 0 #serial can be sent: /hello, /enablemux, disablemux, /getknobs, /led #pd server needs to listen to: /oled/line/X, /oled, /led #pd needs to be sent: /key, /knobs, /quitpd, #server stuff below serialListener = OSC.ThreadingOSCServer( receiveSer ) pdListener = OSC.ThreadingOSCServer( receivePD ) #serial listener needs to listen to: /key, /knobs, /enc, /encbut, /hello serialListener.addMsgHandler("/key", keys) #forward key messages to pd serialListener.addMsgHandler("/knobs", knobs) #forward knob messages to pd ############################################################################### serialListener.addMsgHandler("/enc", enc) serialListener.addMsgHandler("/encbut", encbutton) ############################################################################### pdListener.addMsgHandler("/led", led) # handles LED pd -> stm32 for x in range(1,15): pdListener.addMsgHandler("/oled/line/"+str(x), screenLine) pdListener.addMsgHandler("/oled/vumeter", vuMeter) #draws vu meter on line 0
print 'Reading text' with open('old/texts_all.txt') as file: text = file.read() markovGenerator = markovify.Text(text) # --- JSON (actually slower) # with open('punkMarkov.json') as file: # text = file.read() # markovGenerator = markovify.Text.from_json( text ) # ---------------- print 'Init OSC' oscSender_HostPort = ('127.0.0.1', 6000) # to OpenFrameworks oscReciever_HostPort = ('127.0.0.1', 5000) # python oscSender = OSC.OSCClient() oscReceiver = OSC.ThreadingOSCServer(oscReciever_HostPort) oscSender.connect(oscSender_HostPort) adressCreate = "/create" adressText = "/text" print 'Init done' def recieveMessage(addr, tags, stuff, source): inputLength = int(stuff[0]) print "Received message:", inputLength text = str(markovGenerator.make_short_sentence(inputLength)) print "sending message: " + text messageToSend = OSC.OSCMessage()
#print("Serving on {}".format(server.server_address)) #server.serve_forever() ########################### # EXPERIMENT listen_address = ('localhost', 54321) send_address = ('localhost', 12345) try: #c = OSC.OSCClient() #c.connect(listen_address) s = OSC.ThreadingOSCServer(listen_address)#, c)#, return_port=54321) print s # Set Server to return errors as OSCMessages to "/error" s.setSrvErrorPrefix("/error") # Set Server to reply to server-info requests with OSCMessages to "/serverinfo" s.setSrvInfoPrefix("/serverinfo") # this registers a 'default' handler (for unmatched messages), # an /'error' handler, an '/info' handler. # And, if the client supports it, a '/subscribe' & '/unsubscribe' handler s.addDefaultHandlers() #s.addMsgHandler("/print", printing_handler) s.addMsgHandler("default", printing_handler)