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
