def connectResolume(self): self.Resolume = udp_client.SimpleUDPClient(self.Resolume_IPAddress, self.Resolume_IPPort)
from nltk import pos_tag from gensim.models import KeyedVectors import pickle import os consumer_key = '' consumer_secret = '' access_token = '' access_token_secret = '' auth = tweepy.OAuthHandler(consumer_key, consumer_secret) auth.set_access_token(access_token, access_token_secret) api = tweepy.API(auth) sender = udp_client.SimpleUDPClient('127.0.0.1', 4560) class Listener(StreamListener): def __init__(self, output_file=sys.stdout): super(Listener, self).__init__() self.output_file = output_file def on_status(self, status): if len(prep_text(status.text)) > 0: try: vals = ((get_vec(prep_text(status.text)))) sender.send_message('/play_this', vals[0:14].tolist()) except: pass
def run(port_for_sending): listen_on_myo() global osc_client osc_client = udp_client.SimpleUDPClient( "localhost", port_for_sending) # OSC Client for sending messages.
def updateClient(self): if self.client: del self.client self.client = udp_client.SimpleUDPClient(self.cl_ip, self.cl_port) print('Client updated: ', self.cl_ip, self.cl_port)
from gpiozero import DistanceSensor from time import sleep from pythonosc import osc_message_builder from pythonosc import udp_client sensor2 = DistanceSensor(echo=22, trigger=11) sender2 = udp_client.SimpleUDPClient('127.0.0.1', 4559) val2 = .05 nval2 = .05 while True: if (sensor2.distance != 1.0): nval = (sensor2.distance) #pitch = round(sensor.distance * 100 + 30) #if (pitch <= 80) : #sender.send_message('/play_this', pitch) while (((nval2 - val2) > 0.1) or ((val2 - nval2) > 0.1)): if ((nval2 - val2) > 0.1): nval2 = nval2 - 0.1 if ((val2 - nval2) > .1): nval2 = nval2 + 0.1 sender2.send_message('/vol', val2) val2 = nval2 sleep(.01)
return self.notes[self.current_note] # the code within this if statement is what is run when the program is called # from the command line # # Remember that Python programs start from the bottom and work upwards if __name__ == "__main__": # |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| ########### DO NOT MODIFY THE CODE BETWEEN THESE LINES ################# ip = "127.0.0.1" # the IP of whatever computer this program is running on # do not change this, it is required for OSC communication between # this program and python port = 6449 client = udp_client.SimpleUDPClient(ip, port) args = parseCommandLineArgs() # these allow us to use MANDOLIN instead of 0 when sending /instrument messages MANDOLIN = 0 # variables which are all-caps usually signify constants MODALBAR = 1 # constants do not change their value when the program is running MELODIC = 0 HARMONIC = 1 # sets random values for our instruments parameters # for mandolin pluck_pos = random.random() damping = random.random() detune = random.random() # for modal bar strikePosition = random.random()
def __init__(self, oscaddr, oscport): self.CHAT_MSG = re.compile( r"^:\w+!\w+@\w+\.tmi\.twitch\.tv PRIVMSG #\w+ :") self.oscclient = udp_client.SimpleUDPClient(oscaddr, oscport) self.twitchserver = socket.socket()
time.sleep(.2) #+END_SRC #+RESULTS: 1F53333A-33B1-4FD2-B70D-12742CAE873B :RESULTS: :END: #+NAME: BB244B41-6DA0-427A-BB8C-99FBC3D7E05F #+BEGIN_SRC ein-python :session http://127.0.0.1:8888/notebooks/foobar.ipynb :results raw drawer from pythonosc import udp_client import time localhost = "127.0.0.1" port = 8000 client = udp_client.SimpleUDPClient(localhost, port) # working vert_shader = 'shaders/shader.vert' def msg(id, frag_name, U): client.send_message("/shader/start", True) msgs = [ ("LOAD_FILE", id, vert_shader, frag_name), ("TOGGLE_ACTIVE", id, True)] + \ [("UPDATE_UNIFORM", id, i, U) for i in range(4)] for msg in msgs: time.sleep(.1) print(msg) client.send_message("/graph", msg) print('okay') #+END_SRC
def netdancer(): if pyver3: print(args.host, args.port_osc) c = udp_client.SimpleUDPClient(args.host, args.port_osc) else: c = OSC.OSCClient() c.connect((args.host, args.port_osc)) with h5py.File(args.minmax, 'r') as f: pos_min = f['minmax'][0, :][None, :] pos_max = f['minmax'][1, :][None, :] div = (pos_max - pos_min) div[div == 0] = 1 slope_pos = (rng_pos[1] - rng_pos[0]) / div intersec_pos = rng_pos[1] - slope_pos * pos_max net = imp.load_source('Network', args.model) audionet = imp.load_source('Network', './deepdancer/models/audio_nets.py') model = net.Dancer(args.initOpt, getattr(audionet, args.encoder)) ext = os.path.basename(args.pretrained).split('.') ext = ext[1] if len(ext) > 1 else None try: if ext == 'model': serializers.load_hdf5(args.pretrained, model) else: print(args.pretrained) serializers.load_npz(args.pretrained, model) except Exception as e: raise e model.to_gpu() # current_step = np.random.randn(1,args.initOpt[2]).astype(np.float32) current_step = np.zeros((1, args.initOpt[2]), dtype=np.float32) state = model.state start = False config = {'rot': 'quat'} rot = 'quat' frame = 0 max_frames = 12000 feats = np.zeros((max_frames, args.initOpt[1])) steps = np.zeros((max_frames, 54)) while True: while data_w.empty(): sleep(0.01) inp = data_w.get() if isinstance(inp, str): if inp == 'fail': print('Error during music processing... Exit') break elif inp == 'start': start = True fn = os.path.basename(args.track).split('.')[0] expname = args.pretrained.split('exp/')[1] expname = expname.split('/') expname = '{}_{}'.format(expname[0], expname[1]) if not pyver3: oscmsg = OSC.OSCMessage() oscmsg.setAddress('WidgetTV') if videolink is None: oscmsg.append( 'file:///D:/nyalta/Documents/black/index.html') c.send(oscmsg) oscmsg = OSC.OSCMessage() oscmsg.setAddress('WidgetTV') oscmsg.append( 'file:///D:/nyalta/Documents/black/index.html?dc={}' .format(fn)) c.send(oscmsg) else: oscmsg.append(youtube_link.format(videolink)) c.send(oscmsg) oscmsg = OSC.OSCMessage() oscmsg.setAddress('ExpName') oscmsg.append(expname.replace('_', ' ')) c.send(oscmsg) else: oscmsg = osc_message_builder.OscMessageBuilder( address='WidgetTV') if videolink is None: oscmsg.add_arg( 'file:///D:/nyalta/Documents/black/index.html') c.send(oscmsg.build()) oscmsg = osc_message_builder.OscMessageBuilder( address='WidgetTV') oscmsg.add_arg( 'file:///D:/nyalta/Documents/black/index.html?dc={}' .format(fn)) c.send(oscmsg.build()) else: oscmsg.add_arg(youtube_link.format(videolink)) c.send(oscmsg.build()) oscmsg = osc_message_builder.OscMessageBuilder( address='ExpName') oscmsg.add_arg(expname.replace('_', ' ')) c.send(oscmsg.build()) continue elif inp == 'end': if enable_record: ws.call(requests.StopRecording()) ws.disconnect() start = False fn = os.path.basename(args.track).split('.')[0] fn = '{}/{}_feats.h5'.format(args.save, fn) with h5py.File(fn, 'w') as f: f.create_dataset('feats', data=feats[0:frame]) f.create_dataset('steps', data=steps[0:frame]) # osc_message_buildercmsg = OSC.OSCMessage() if pyver3: pass else: oscmsg.setAddress('ExpName') oscmsg.append('ExpName') c.send(oscmsg) break if start: t = time.time() _, audiodata = inp try: with chainer.no_backprop_mode(), chainer.using_config( 'train', False): _h, state, current_step = model.forward( state, Variable(xp.asarray(current_step)), model.audiofeat( Variable(xp.asarray(audiodata[None, None, :, :]))), True) except Exception as e: print(audiodata.shape) raise e current_step = chainer.cuda.to_cpu(current_step.data) predicted_motion = (current_step - intersec_pos) / slope_pos rdmt = render_motion(predicted_motion, rot, scale=args.height) if frame < max_frames: feats[frame] = chainer.cuda.to_cpu(_h.data) steps[frame] = rdmt[0] for i in range(len(list_address)): if pyver3: oscmsg = osc_message_builder.OscMessageBuilder( address=args.character) oscmsg.add_arg(list_address[i]) if i == 0: oscmsg.add_arg(float(rdmt[0, 0] / 10.0)) oscmsg.add_arg(float(rdmt[0, 1] / -10.0)) oscmsg.add_arg(float(rdmt[0, 2] / 10.0 + args.height)) else: oscmsg.add_arg(float(rdmt[0, i * 3])) oscmsg.add_arg(float(rdmt[0, i * 3 + 1] * -1.)) oscmsg.add_arg(float(rdmt[0, i * 3 + 2] * -1.)) c.send(oscmsg.build()) else: oscmsg = OSC.OSCMessage() oscmsg.setAddress(args.character) oscmsg.append(list_address[i]) if i == 0: msg = [ rdmt[0, 0] / 10.0, rdmt[0, 1] / -10.0, rdmt[0, 2] / 10.0 + args.height ] else: msg = [ rdmt[0, i * 3], rdmt[0, i * 3 + 1] * -1., rdmt[0, i * 3 + 2] * -1. ] oscmsg += msg c.send(oscmsg) frame += 1 stdout.write('Frame: {:06d}, time: {:.03f}\r'.format( frame, time.time() - t)) stdout.flush() return
#!/usr/bin/python3 #$/home/pi/WLC-Button-OSC/osc-button.py import time import math from pythonosc import osc_message_builder from pythonosc import udp_client from pythonosc import dispatcher #the below IP addres is what you are talking to and the listening port client = udp_client.SimpleUDPClient("192.168.1.95", 53000) ### Input setup here: import RPi.GPIO as GPIO GPIO.setmode(GPIO.BCM) #Go Button GPIO.setup(18, GPIO.IN, pull_up_down=GPIO.PUD_UP) #Stop Button GPIO.setup(27, GPIO.IN, pull_up_down=GPIO.PUD_UP) #Pause Button GPIO.setup(22, GPIO.IN, pull_up_down=GPIO.PUD_UP) #changed to event detection to allow for non linear pressing of buttons #Falling equals when you press rising equal release. #You could standby with a press and go with release. # GPIO.add_event_detect(18, GPIO.FALLING, bouncetime=500) GPIO.add_event_detect(27, GPIO.FALLING, bouncetime=500) GPIO.add_event_detect(22, GPIO.FALLING, bouncetime=500)
from pythonosc import osc_message_builder from pythonosc import udp_client #client = udp_client.SimpleUDPClient("192.168.5.5", 3030) client = udp_client.SimpleUDPClient("0.0.0.0", 3030) def send_osc(route, message): client.send_message(route, message)
import argparse import sys from pythonosc import osc_message_builder from pythonosc import udp_client parser = argparse.ArgumentParser(description='Connects to a Myo, then sends EMG and IMU data as OSC messages to localhost:3000.') parser.add_argument('-l', '--log', dest='logging', action="store_true", help='Save Myo data to a log file.') parser.add_argument('-d', '--discover', dest='discover', action='store_true', help='Search for available Myos and print their names and MAC addresses.') parser.add_argument('-a', '--address', dest='address', help='A Myo MAC address to connect to, in format "XX:XX:XX:XX:XX:XX".') args = parser.parse_args() LOG_FILE = datetime.datetime.now().isoformat().replace(":", "-")[:19] + "-myo-to-osc.log" # Log file name. LOG_FORMAT = '%(message)s' osc_client = udp_client.SimpleUDPClient("localhost", 3000) # OSC Client for sending messages. def vector_3d_magnitude(x, y, z): """Calculate the magnitude of a 3d vector""" return math.sqrt((x * x) + (y * y) + (z * z)) def toEulerAngle(w, x, y, z): """ Quaternion to Euler angle conversion borrowed from wikipedia. https://en.wikipedia.org/wiki/Conversion_between_quaternions_and_Euler_angles """ # roll (x-axis rotation) sinr = +2.0 * (w * x + y * z) cosr = +1.0 - 2.0 * (x * x + y * y) roll = math.atan2(sinr, cosr) # pitch (y-axis rotation)
def send_osc(ip, port, msg): client = udp_client.SimpleUDPClient(ip, port) client.send_message(msg.pop(0), msg)
def __init__(self, task_settings, user_settings, debug=False, fmake=True): self.DEBUG = debug make = False if not fmake else ["video"] # ===================================================================== # IMPORT task_settings, user_settings, and SessionPathCreator params # ===================================================================== ts = { i: task_settings.__dict__[i] for i in [x for x in dir(task_settings) if "__" not in x] } self.__dict__.update(ts) us = { i: user_settings.__dict__[i] for i in [x for x in dir(user_settings) if "__" not in x] } self.__dict__.update(us) self = iotasks.deserialize_pybpod_user_settings(self) spc = SessionPathCreator(self.PYBPOD_SUBJECTS[0], protocol=self.PYBPOD_PROTOCOL, make=make) self.__dict__.update(spc.__dict__) # ===================================================================== # SUBJECT # ===================================================================== self.SUBJECT_WEIGHT = user.ask_subject_weight(self.PYBPOD_SUBJECTS[0]) self.SUBJECT_DISENGAGED_TRIGGERED = False self.SUBJECT_DISENGAGED_TRIALNUM = None # ===================================================================== # OSC CLIENT # ===================================================================== self.OSC_CLIENT_PORT = 7110 self.OSC_CLIENT_IP = "127.0.0.1" self.OSC_CLIENT = udp_client.SimpleUDPClient(self.OSC_CLIENT_IP, self.OSC_CLIENT_PORT) # ===================================================================== # PREVIOUS DATA FILES # ===================================================================== self.LAST_TRIAL_DATA = iotasks.load_data(self.PREVIOUS_SESSION_PATH) self.LAST_SETTINGS_DATA = iotasks.load_settings(self.PREVIOUS_SESSION_PATH) # ===================================================================== # ADAPTIVE STUFF # ===================================================================== self.AR_MIN_VALUE = 1.5 if "Sucrose" in self.REWARD_TYPE else 2.0 self.REWARD_AMOUNT = adaptive.init_reward_amount(self) self.CALIB_FUNC = None if self.AUTOMATIC_CALIBRATION: self.CALIB_FUNC = adaptive.init_calib_func() self.CALIB_FUNC_RANGE = adaptive.init_calib_func_range() self.REWARD_VALVE_TIME = adaptive.init_reward_valve_time(self) self.STIM_GAIN = adaptive.init_stim_gain(self) self.IMPULSIVE_CONTROL = "OFF" self = adaptive.impulsive_control(self) # ===================================================================== # frame2TTL # ===================================================================== self.F2TTL_GET_AND_SET_THRESHOLDS = frame2TTL.get_and_set_thresholds() # ===================================================================== # ROTARY ENCODER # ===================================================================== self.ALL_THRESHOLDS = self.STIM_POSITIONS + self.QUIESCENCE_THRESHOLDS self.ROTARY_ENCODER = MyRotaryEncoder( self.ALL_THRESHOLDS, self.STIM_GAIN, self.PARAMS["COM_ROTARY_ENCODER"] ) # ===================================================================== # SOUNDS # ===================================================================== self.SOFT_SOUND = None if "ephys" in self.PYBPOD_BOARD else self.SOFT_SOUND self.SOUND_SAMPLE_FREQ = sound.sound_sample_freq(self.SOFT_SOUND) self.WHITE_NOISE_DURATION = float(self.WHITE_NOISE_DURATION) self.WHITE_NOISE_AMPLITUDE = float(self.WHITE_NOISE_AMPLITUDE) self.GO_TONE_DURATION = float(self.GO_TONE_DURATION) self.GO_TONE_FREQUENCY = int(self.GO_TONE_FREQUENCY) self.GO_TONE_AMPLITUDE = float(self.GO_TONE_AMPLITUDE) self.SD = sound.configure_sounddevice( output=self.SOFT_SOUND, samplerate=self.SOUND_SAMPLE_FREQ ) # Create sounds and output actions of state machine self.SOUND_BOARD_BPOD_PORT = "Serial3" self.GO_TONE = None self.WHITE_NOISE = None self.GO_TONE_IDX = 2 self.WHITE_NOISE_IDX = 3 self = sound.init_sounds(self) # sets GO_TONE and WHITE_NOISE if self.SOFT_SOUND is None: sound.configure_sound_card( sounds=[self.GO_TONE, self.WHITE_NOISE], indexes=[self.GO_TONE_IDX, self.WHITE_NOISE_IDX], sample_rate=self.SOUND_SAMPLE_FREQ, ) self.OUT_STOP_SOUND = ("SoftCode", 0) if self.SOFT_SOUND else ("Serial3", ord("X")) self.OUT_TONE = ("SoftCode", 1) if self.SOFT_SOUND else ("Serial3", 6) self.OUT_NOISE = ("SoftCode", 2) if self.SOFT_SOUND else ("Serial3", 7) # ===================================================================== # RUN VISUAL STIM # ===================================================================== bonsai.start_visual_stim(self) # ===================================================================== # SAVE SETTINGS FILE AND TASK CODE # ===================================================================== if not self.DEBUG: iotasks.save_session_settings(self) iotasks.copy_task_code(self) iotasks.save_task_code(self) iotasks.copy_video_code(self) iotasks.save_video_code(self) self.bpod_lights(0) self.display_logs()
GamaSpace_Rotation = round(args[0], 2) def MainGallery_handler(address, *args): global MainGalleryRotation MainGalleryRotation = round(args[0], 2) dispatcher = Dispatcher() dispatcher.map("/GamaSpaceRot", GamaSpace_handler) dispatcher.map("/MainGalleryRot", MainGallery_handler) ip = "192.168.0.186" port = 3000 GammaSpace_SSU = udp_client.SimpleUDPClient("192.168.0.228", 4005) #MainGallery_SSU = udp_client.SimpleUDPClient("192.168.0.2280", 6005) # main Function of the loop # here constantly check if both values are equal async def loop(): """ Compare the Numbers coming from Raspberry pi""" while 1: print("GamaSpaceRotation: ", GamaSpace_Rotation) print("MainGalleryRotation: ", MainGalleryRotation) if GamaSpace_Rotation == MainGalleryRotation: print("were facing the same way")
count = 0 data = [0,] * 31 for marker in markers: x = payload['markers'][marker]['position']['x'] y = payload['markers'][marker]['position']['y'] if not path.contains_point((x,y), radius=1.2): #print('True') data[data[1:].index(0)+1] = x data[data[1:].index(0)+1] = y count += 1 data[0] = count ocs_client.send_message('/data', data) try: ocs_client = udp_client.SimpleUDPClient('127.0.0.1', 9000) path = mPath.Path(((0,9.2),(3.4,10.5),(2.2,14.9),(-1.7,14.4))) mqttc = mqtt.Client() mqttc.on_message = on_message print("Setting user credentials") mqttc.username_pw_set(username=MQTT_USERNAME, password=MQTT_PASSWORD) print("Connecting to host %s" % HOSTNAME) mqttc.connect(HOSTNAME, 1883, 60) print("Subscribing to topic %s" % TOPIC) mqttc.subscribe(TOPIC, 0) print("Looping forever...")
import numpy as np import soundcard as sc from struct import unpack from essentia.streaming import * from essentia import Pool, run, array, reset import argparse import requests from pythonosc import dispatcher from pythonosc import osc_server from pythonosc import udp_client import json client = udp_client.SimpleUDPClient('127.0.0.3', 5010) #this client sends to SC sampleRate = 44100 frameSize = 2048 hopSize = 2048 numberBands = 3 patchSize = 60 #control the velocity of the extractor 20 is approximately one second of audio displaySize = 10 bufferSize = patchSize * hopSize buffer = np.zeros(bufferSize, dtype='float32') vectorInput = VectorInput(buffer) frameCutter = FrameCutter(frameSize=frameSize, hopSize=hopSize) w = Windowing(type='hann') spec = Spectrum() mfcc = MFCC(numberCoefficients=13) pool = Pool()
#This program listens to several addresses, and prints some information about received packets. import argparse import math import requests # importing the requests library from pythonosc import dispatcher from pythonosc import osc_server from pythonosc import udp_client import json client = udp_client.SimpleUDPClient('127.0.0.1', 5006) #this client sends to SC def tf_handler(unused_addr, *args): # sending get request and saving the response as response object headers = {"content-type": "application/json"} data = {"instances": [[*args]]} r = requests.post( url="http://localhost:8501/v1/models/improv_class:predict", data=json.dumps(data), headers=headers) # extracting data in json format data = r.json()["predictions"] client.send_message("/clase", *data) #caotico = data[0][0] complejo = data[0][0] fijo = data[0][1] periodico = data[0][2]
print("Cleaning Up GPIO pins") GPIO.cleanup() stopServer() sys.exit() signal.signal(signal.SIGINT, sigint_handler) ''' ' OSC Set up ' The arm right now is set up to only receive ''' server_ip = "0.0.0.0" server_port = 12000 server_thread = None server = None client = udp_client.SimpleUDPClient("localhost", server_port) motion = "stop" #Used for the 2 motor drivers global lowerDriver global higherDriver global startTime global step #Used For motor Names BASE = "base" CENTER = "center" PIVOT = "pivot" CLAW = "claw" def setupMotors():
import random import time from pythonosc import osc_message_builder from pythonosc import udp_client client = udp_client.SimpleUDPClient("127.0.0.1", 8000) dest = [ "/red/scale", "/red/offset", "/red/speed", "/green/scale", "/green/offset", "/green/speed", "/blue/scale", "/blue/offset", "/blue/speed", "/shape/size", "/shape/sides", "/shape/xinc", "/shape/yinc", "/shape/xcenter", "/shape/ycenter", "/shape/shapecount", "/shape/shapeskip", "/global/strobe", "/global/invert" ] def random_test(): val_set = random.randrange(0, 255) dest_s = dest[random.randrange(0, len(dest))] client.send_message(dest_s, val_set) print("sent {} to {}".format(val_set, dest_s)) while True: random_test() time.sleep(1)
def start_client(ip, port): print("Starting Client") client = udp_client.SimpleUDPClient(ip, port) # print("Sending on {}".format(client.)) thread = threading.Thread(target=random_values(client)) thread.start()
from flask import Flask from pythonosc import osc_message_builder from pythonosc import udp_client from flask import request import spacy import subprocess app = Flask(__name__) osc_client = udp_client.SimpleUDPClient("127.0.0.1", 57120) @app.route('/speech') def speech(): text = request.args.get('text') print('Text:' + text) command = 'gtts-cli ' + text + '| sox -t mp3 - /tmp/sctest.wav' subprocess.run(command, shell=True, check=True) osc_client.send_message("/speech", 666) return 'Hello 2 World! Sent OSC' if __name__ == "__main__": # Load English tokenizer, tagger, parser, NER and word vectors nlp = spacy.load('en') # Determine semantic similarities doc1 = nlp(u"my fries were super gross") doc2 = nlp(u"How are you today?") similarity = doc1.similarity(doc2)
def __init__(self): self.root = tk.Tk() self.root.title(APP_NAME) self.root.config(bg=COLOR_SCHEME['panel_bg']) hs = self.root.winfo_screenheight() self.root.geometry('1200x600+0+%d' % (hs / 2)) #self.root.resizable(0, 0) #self.style = Style() #self.style.theme_use('clam') self.cl_ip = CLIENT_ADDR self.cl_port = CLIENT_PORT self.sv_ip = SERVER_ADDR self.sv_port = SERVER_PORT #self.client = udp_client.SimpleUDPClient(self.cl_ip, self.cl_port) self.updateClient() # for TouchOSC app... self.touchOSCdisp = dispatcher.Dispatcher() self.touchOSCdisp.map('/*', self.parseOSC) self.touchOSCServer = osc_server.BlockingOSCUDPServer( TOUCH_OSC_SERVER, self.touchOSCdisp) self.touchOSCClient = udp_client.SimpleUDPClient(*TOUCH_OSC_CLIENT) # setup managers... self.queue_manager = multiprocessing.Manager() self.request_queue = self.queue_manager.Queue() self.network_manager = NetworkManager(self.request_queue) self.network_manager.start() self.mainframe = tk.Frame(self.root, bg=COLOR_SCHEME['panel_bg']) #self.mainframe.pack_propagate(False) self.mainframe.pack(fill='both', expand=True) self.mainframe.columnconfigure(0, weight=1) #self.mainframe.rowconfigure(0, weight=1) # main control panel... self.maincontrols = tk.Frame(self.mainframe, bg=self.mainframe.cget('bg')) timeFont = font.Font(family='Courier', size=12, weight='bold') self.timeLabel = tk.Label(self.maincontrols, text='00:00', bg='#303030', fg='orange', width=10, relief='sunken', bd=2, font='Arial 16', padx=5, pady=5) self.BPM = tk.IntVar(self.maincontrols) self.bpmBox = tk.Spinbox(self.maincontrols, from_=20, to=240, textvariable=self.BPM, width=3, bg=self.maincontrols.cget('bg'), fg=COLOR_SCHEME['text_light'], buttonbackground=self.maincontrols.cget('bg')) self.panicButton = tk.Button(self.maincontrols, text='all off', command=self.panic, bg=self.maincontrols.cget('bg'), activebackground='orange', activeforeground='black', fg=COLOR_SCHEME['text_light']) # pack main controls... self.timeLabel.grid(row=0, column=4, rowspan=2, padx=5) tk.Label(self.maincontrols, text='Tempo:', fg=COLOR_SCHEME['text_light'], bg=self.maincontrols.cget('bg')).grid(row=0, column=5, sticky='e') self.bpmBox.grid(row=0, column=6) self.panicButton.grid(row=1, column=5, columnspan=2, sticky='ew') # add clock... self.clockQueue = multiprocessing.Queue() mgr = multiprocessing.Manager() self.clockVar = mgr.dict() self.clock = Clock(self.client, self.clockVar, self.clockQueue) self.BPM.trace('w', self.BPMchange) self.BPM.set(80) # add instrument button and panels... #self.instrumentsBox = tk.Frame(self.mainframe, relief='sunken', bd=2, bg=COLOR_SCHEME['note_panel_bg']) self.instrumentsBox = VScrollFrame( self.mainframe, relief='sunken', bd=2, ) self.ins_manager = InstrumentManager(self.instrumentsBox, self.client, self.request_queue, self.queue_manager, self.clockVar, self.touchOSCClient) #self.ins_manager.addInstrument() # add engine... #self.engine = Engine(self, self.ins_manager, self.BPM, touchOSCClient=self.touchOSCClient) self.engine = Engine(self, self.client, self.clockVar, self.clockQueue, self.ins_manager) # add controls... self.controls = PlayerControls(self.maincontrols, self, self.engine) self.controls.grid(row=0, column=0, rowspan=2) # add status bar... self.statusBar = tk.Frame(self.mainframe, relief='sunken', bg=COLOR_SCHEME['dark_grey'], bd=2) self.statusLabel = tk.Label(self.statusBar, bg=self.statusBar.cget('bg'), fg=COLOR_SCHEME['text_light'], text='Connecting too: {}, Port:{}'.format( self.cl_ip, self.cl_port)) self.statusLabel.bind('<Button-1>', self.editConnection) self.statusLabel.pack(side='right') # place everything... #self.maincontrols.pack(padx=5, pady=5) #self.instrumentsBox.pack(fill='both', expand=True, ipadx=4, ipady=4) #self.statusBar.pack(side='bottom', fill='x') self.mainframe.grid_rowconfigure(1, weight=1) self.maincontrols.grid(row=0, column=0) #self.instrumentsBox.grid(row=1, column=0, sticky='nsew') self.statusBar.grid(row=2, column=0, sticky='ew') # add OSC listeners... self.disp = dispatcher.Dispatcher() self.disp.map('/pingReply', self.pingReply, self.statusLabel) self.disp.map('/cc', self.ccRecieve) self.disp.map('/noteOn', self.noteOn) self.joystick_moved = False self.updateServer() self.listener = MessageListener(self.server) self.touchOSCListener = MessageListener(self.touchOSCServer) # start the loops... self.engine.daemon = True self.clock.start() self.engine.start() self.listener.start() self.touchOSCListener.start() self.checkConnection() self.updateGUI() self.root.mainloop() # tidy up on close... print('Closing threads...') self.ins_manager.send_message('/panic', 0) mgr.shutdown() self.engine.join(timeout=1) self.clock.join(timeout=1) self.listener.join(timeout=1) self.touchOSCListener.join(timeout=1) self.network_manager.terminate() self.network_manager.join(timeout=1)
def send_osc_message(messages): address = "192.168.0.20" port = 7000 osc_name = "/AAAA" client = udp_client.SimpleUDPClient(address, port) client.send_message(osc_name, messages)
def bmdsend(message): client = udp_client.SimpleUDPClient(bmdoschost, bmdoscport) client.send_message(message, None)
def __init__(self, queue): super().__init__() self.queue = queue self.sender = udp_client.SimpleUDPClient('127.0.0.1', 4559) self.decimate = 0
import argparse import random import time import sys from pythonosc import osc_message_builder from pythonosc import udp_client from aubio import source, notes, pitch parser = argparse.ArgumentParser() parser.add_argument("--ip", default="127.0.0.1", help="The ip of the OSC server") parser.add_argument("--port", type=int, default=5005, help="The port the OSC server is listening on") args = parser.parse_args() client = udp_client.SimpleUDPClient(args.ip, args.port) for filename in sys.stdin: downsample = 1 samplerate = 44100 // downsample win_s = 2048 // downsample # fft size hop_s = 512 // downsample # hop size s = source(filename.strip(), samplerate, hop_s) samplerate = s.samplerate tolerance = 0.8 notes_o = notes("default", win_s, hop_s, samplerate) notes_o.set_silence(-40)
osc_synth.send_message(PREDICTION_MESSAGE_ADDRESS, osc_arguments[0]) def interaction_loop(): """Interaction loop for the box, reads serial, makes predictions, outputs servo and sound.""" userloc = np.random.rand() # Fake data if userloc is not None: if args.verbose: print("Input:", userloc) osc_predictor.send_message(INTERFACE_MESSAGE_ADDRESS, userloc) osc_synth.send_message(INTERFACE_MESSAGE_ADDRESS, userloc) # Set up OSC client and server osc_predictor = udp_client.SimpleUDPClient(args.predictorip, args.predictorport) osc_synth = udp_client.SimpleUDPClient(args.synthip, args.synthport) disp = dispatcher.Dispatcher() disp.map(PREDICTION_MESSAGE_ADDRESS, handle_prediction_message) server = osc_server.ThreadingOSCUDPServer((args.serverip, args.serverport), disp) server_thread = Thread(target=server.serve_forever, name="server_thread", daemon=True) print("Interface server started.") print("Serving on {}".format(server.server_address)) thread_running = False print("starting up.")
def __init__(self, ip="127.0.0.1", port=57121, name="/note"): self.name = name self.client = udp_client.SimpleUDPClient(ip, port)
# Magic Mirror Led Controller - CLIENT # Created for the GDA production of Beauty and the Beast # Written by Andrew Farabow import argparse import random import time from pythonosc import osc_message_builder from pythonosc import udp_client if __name__ == "__main__": # connect to the pi client = udp_client.SimpleUDPClient("127.0.0.1", 5005) # loop infinitly while True: # allow user to select on or off print("Press 0 for Off, 1 for On (White)") selection = input("Enter A Number: ") if selection == "0": client.send_message("/mode", False) # off if selection == "1": client.send_message("/mode", True) # on