def updateMac(request):
if request.method == 'POST':
mac_muse = request.POST['muse-mac']
raspb_mac = request.POST['raspberry-mac']
raspb = rasp_device.objects.get(mac_address=raspb_mac)
if mac_muse == '':
free_muse = raspb.connected_muse
if free_muse != None:
free_muse.used = False
free_muse.save()
raspb.connected_muse = None
if raspb.ip != None:
print("sending message to disconnect")
c = liblo.Message('/change_mac', 'disconnected')
outputAddress = liblo.Address(raspb.ip, 6001)
liblo.send(outputAddress, c)
else:
free_muse = raspb.connected_muse
if free_muse != None:
free_muse.used = False
free_muse.save()
muse = muse_device.objects.get(mac_address=mac_muse)
raspb.connected_muse = muse
muse.used = True
muse.save()
if raspb.ip != None:
print("sending message")
c = liblo.Message('/change_mac', raspb.connected_muse.mac_address)
outputAddress = liblo.Address(raspb.ip, 6001)
liblo.send(outputAddress, c)
raspb.save()
return HttpResponseRedirect('/')
def __init__(self, *args, **kwargs):
super(meshTrimesh, self).__init__()
# create a mesh with mesh generation parameters
self.mesh = self.make_mesh_triangle_trimesh(**kwargs)
# compute the neighbors for each cell
self.valid_neighbors_all = self.mesh_get_neighbors_trimesh(self.mesh)
# print('valid_neighbors_all = {0}'.format(self.valid_neighbors_all))
# extend the mesh with an attribute dictionary
self.tris = self.mesh_extended_trimesh(self.mesh)
self.osc = kwargs['osc']
# self.osc_target = liblo.Address('localhost', 1234)
# self.osc_target = '1234'
self.osc_target = liblo.Address('localhost', 1234, liblo.UDP)
self.osc_target_hexagon = liblo.Address('localhost', 1236, liblo.UDP)
self.sensors = [0.0 for _ in range(6)]
# self.coupling = 0.2
self.coupling = 0.02
# self.coupling = 0.005
self.isrunning = True
self.cnt = 0
def __init__(self, *a, **k):
# pick up osc server
self.osc = k.pop('osc', self.osc)
# jack.osc controls the jack transport
jack_osc_port = get_free_port()
self._jack_osc_address = liblo.Address(jack_osc_port)
self._jack_osc = run('jack.osc', '-p', str(jack_osc_port))
# klick is jack tempo master
klick_port = get_free_port()
self._klick_address = liblo.Address(klick_port)
self._klick = run('klick', '-T', '-P', '-v', '1.0', str(self.meter),
str(self.tempo))
# listen to jack.osc's timing messages
self.osc.send(self._jack_osc_address, '/receive', 0xfffffff)
self.osc.add_method('/pulse', None, self.on_osc_pulse)
self.osc.add_method('/tick', None, self.on_osc_tick)
self.osc.add_method('/drift', None, self.on_osc_drift)
self.osc.add_method('/transport', None, self.on_osc_transport)
# do the standard transport stuff
super(JACKOSCKlickTransport, self).__init__(*a, **k)
def osc_init(self, proto=liblo.UDP):
self.start_loading()
try:
self.osc_target=liblo.Address('localhost',self.osc_target_port,proto)
logging.info("OSC target in port %s" % str(self.osc_target_port))
self.osc_server=liblo.ServerThread(None,proto)
self.osc_server_port=self.osc_server.get_port()
self.osc_server_url=liblo.Address('localhost',self.osc_server_port,proto).get_url()
logging.info("OSC server running in port %s" % str(self.osc_server_port))
self.osc_add_methods()
self.osc_server.start()
except liblo.AddressError as err:
logging.error("OSC Server can't be initialized (%s). Running without OSC feedback." % err)
self.stop_loading()
def connect(self, host, port, proto=liblo.UDP):
'''connect to a osc server'''
try:
if not self.__thread_started:
self.target = liblo.Address(host, port, proto)
self.start()
self.__await_connect = True
self.__conreq = LibloClient.ConnectRequest(self)
self.__conreq.start()
else:
self.target = liblo.Address(host, port, proto)
self.reconnect(host, port)
except liblo.AddressError as err:
print("TODO Error Handling", err)
return
def sendBurst(self, path, *args):
self.burstCounter += 1
target = liblo.Address("osc.udp://" + self.hostOut + ":" +
str(self._portOut))
for i in range(5):
liblo.send(target, '/burst', self.ethMac, self.burstCounter, path,
*args)
def __init__(self, root, port, commands) :
self.currentSession = ""
self.sessionRoot = root
if not os.path.exists(self.sessionRoot) :
os.makedirs(self.sessionRoot)
self.nsm_server = Server(port+1)
self.sfx_server = Server(port+2)
self.url = 'osc.udp://localhost:' + str(port)
self.address = liblo.Address(self.url)
os.environ['NSM_URL'] = self.url
os.environ['SFX_URL'] = self.sfx_server.url
self.commands = commands
self.isRunning = True
self.daemon = sp.Popen(["nsmd", "--session-root", self.sessionRoot, "--osc-port", str(port)], env=os.environ)
self.sfx_server.server.add_method('/sfx/new/client', None, sfx_new_client_callback, self)
self.sfx_server.server.add_method('/sfx/new/method', None, sfx_new_method_callback, self)
self.sfx_server.server.start()
print('NSM_URL =', os.environ['NSM_URL'])
print('SFX_URL =', os.environ['SFX_URL'])
def __init__(self, host2='localhost', port2=5002):
super(CarClient, self).__init__(host2, port2)
#self.carsReady = False
self.carsReady = True
self.ser = None
self.theta = 2
self.isDriving = False
self.lastWrite = int(time())
self.numberOfBytesToRead = CarPacket.size()
# self.screen_client = udp_client.UDPClient('127.0.0.1', 7002)
self.screen_client2 = liblo.Address('127.0.0.1', 7002)
try:
self.ser = serial.Serial(device_location,
9600,
bytesize=serial.EIGHTBITS,
parity=serial.PARITY_NONE,
stopbits=serial.STOPBITS_ONE,
timeout=None)
except NameError:
logging.error("serial not available")
except serial.serialutil.SerialException:
logging.error("serial not available")
logging.info("initialized")
def as_liblo_address(addr):
if isinstance(addr, liblo.Address):
return addr
elif isinstance(addr, tuple):
return liblo.Address(*addr)
else:
raise TypeError("did not undersand addr")
def __init__ (self, old_owner):
#self.oscaddress = liblo.Address("192.168.0.20", 8188)
self.oscaddress = liblo.Address("localhost", 8188)
self.startingPosition = Vector((0.0, 0.0, 0.0))
self.cont = bge.logic.getCurrentController()
self.obj = self.cont.owner
self.curScene = None
self.tagetPosition = None
self.oscurl = None
self.id = None
self.control = None
self.group = None
self.isDynamic = False
self.active = False
self.forceAffected = True
self.alpha = self.color[3]
self.moving = False
self.chosen = False
self.currentPosition = 0
self.valveForce = 0
self.toUpdate = []
self.callbacks = {}
self.speed = Vector((0.0, 0.0, 0.0))
self.destination = Vector((0.0, 0.0, 0.0))
self.positions = [
Vector((4.468418121337891, -4.627209186553955, 3.5)),
# self.startingPosition
]
def main(args):
screen = display.Display().screen()
swidth = screen["width_in_pixels"]
sheight = screen["height_in_pixels"]
target = liblo.Address(args.host, args.port)
N = int(args.dims)
p = int(args.bits)
tbits = N * p
fp = 2.0**p
screen_max = 2**11
total_screen_max = 2**(2 * 11)
dim_max = 2**tbits
last_h = -1
while True:
x, y = getXY()
x = screen_max * x / swidth
y = screen_max * y / sheight
h = hilbert.distance_from_coordinates([x, y], 11, 2) # 2048x2048
new_h = dim_max * h / total_screen_max
new_x = hilbert.coordinates_from_distance(new_h, p, N)
if last_h != new_h:
print(h, new_h, new_x)
new_xf = map(lambda x: x / fp, new_x)
liblo.send(target, "/mouse", *new_xf)
last_h = new_h
time.sleep(1.0 / 30.0)
def __init__(self, gui, host, port, protocol, instance, local_port):
threading.Thread.__init__(self)
self.daemon = True
self.gui = gui
self.address = liblo.Address(host, port, protocol)
self.server_active = False
try:
searching_port = True
ntrials = 0
while searching_port:
try:
self.server = liblo.Server(local_port)
searching_port = False
except liblo.ServerError, err:
local_port = local_port + 1
ntrials = ntrials + 1
if ntrials > 1000:
raise liblo.ServerError(99, "stop searching free port",
None)
self.server.add_method(
"/net/mhcloud/volume/" + instance + "/master", "f",
self.callback_master_gain)
self.server.add_method(
"/net/mhcloud/volume/" + instance + "/master/mute", "i",
self.callback_master_mute)
for i in range(channels):
self.server.add_method(
"/net/mhcloud/volume/" + instance + "/" + str(i), "f",
self.callback_channel_gain, i)
self.server.add_method(
"/net/mhcloud/volume/" + instance + "/" + str(i) + "/mute",
"i", self.callback_channel_mute, i)
self.server_active = True
def __init__(self, *a, **k):
self.osc_port = k.get('port', self.osc_port) or get_free_port()
self.osc_address = liblo.Address(self.osc_port)
super(XJadeoTrack, self).__init__(*a, **k)
self.sooperlooper = run('xjadeo',
'-J',
'-O', str(self.osc_port))
def __init__(self, address=("localhost", 9000), listen_port=9001):
self.beat_callback = None
self.startup_callback = None
self.listen_port = listen_port
#------------------------------------------------------------------------
# Handler callbacks for particular messages from Live.
# Used so that other processes can register callbacks when states change.
#------------------------------------------------------------------------
self.handlers = {}
self.osc_address = address
self.osc_target = liblo.Address(address[0], address[1])
self.osc_server = liblo.Server(listen_port)
self.osc_server.add_method(None, None, self.handler)
self.osc_server_thread = None
self.osc_server.add_bundle_handlers(self.start_bundle_handler,
self.end_bundle_handler)
self.osc_read_event = None
self.osc_timeout = 3.0
self.osc_server_events = {}
self.query_address = None
self.query_rv = []
self.listen()
def main():
if not len(sys.argv) >= 2:
print "Usage: rebroadcast_recording.py [ip:port [ip:port ...]] recording_filename"
sys.exit(2)
else:
video_flags = OPENGL | DOUBLEBUF
pygame.init()
pygame.display.set_caption("Kinect handtracker demo (#pmrhack)")
# setup targets
pygame.display.set_mode((640, 480), video_flags)
resize((640, 480))
init()
frames = 0
ticks = pygame.time.get_ticks()
l = list(sys.argv)
prog = l.pop(0)
state = UserState()
filename = l.pop()
for entry in l:
m = ip_p.match(entry)
if m != None:
d = m.groups()
endpoints.append((d[0], d[1]))
print "Rebroadcasting '%s' to the following endpoints:" % filename
for ep in endpoints:
print "-- %s, port %s" % (ep[0], ep[1])
targets.append(liblo.Address(ep[0], ep[1]))
with open(filename, "r") as inp:
line = inp.readline()
while (line):
event = pygame.event.poll()
if event.type == QUIT or (event.type == KEYDOWN
and event.key == K_ESCAPE):
break
draw(state)
pygame.display.flip()
frames = frames + 1
i, rx, ry, rz, lx, ly, lz, rsx, rsy, rsz, lsx, lsy, lsz = line.split(
",")
state.update(i, rx, ry, rz, lx, ly, lz, rsx, rsy, rsz, lsx,
lsy, lsz)
for target in targets:
liblo.send(target, "/combined", i, rx, ry, rz, lx, ly, lz,
rsx, rsy, rsz, lsx, lsy, lsz)
print "User:%s - Hands r(%s,%s,%s), l(%s,%s,%s)" % (
i, rx, ry, rz, lx, ly, lz)
print "User:%s - Shoulders r(%s,%s,%s), l(%s,%s,%s)" % (
i, rx, ry, rz, lx, ly, lz)
line = inp.readline()
print "End of recording"
print "fps: %d" % ((frames * 1000) /
(pygame.time.get_ticks() - ticks))
def initNetwork(self):
def onPlay(path, args):
self.timer.start(args[0])
def onPause(path, args):
self.timer.pause(args[0])
def onStop(path, args):
self.timer.stop(args[0])
def onSeek(path, args):
self.timer.seek(args[0], args[1])
self.server = liblo.ServerThread(self.network.port, group="224.0.0.1")
self.server.add_method("/play", "t", onPlay)
self.server.add_method("/pause", "t", onPause)
self.server.add_method("/stop", "t", onStop)
self.server.add_method("/seek", "tt", onSeek)
#self.server.add_method(None, None, self.onMessageReceived)
self.server.start()
self._broadcast = liblo.Address("224.0.0.1", self.network.port,
liblo.UDP)
self._broadcast.ttl = 1
def onTimeout():
value = self.timer._clock.time
liblo.send(self._broadcast, "/time", ('t', value))
self._heartbeat = QtCore.QTimer()
self._heartbeat.timeout.connect(onTimeout)
def update(self):
"""
update is called when value is updated
might be used to send it to network or other protocols
"""
for out in self.parent.get_device().outputs:
try:
split = out.port.split(':')
ip_add = split[0]
udp = split[1]
try:
target = liblo.Address(ip_add, int(udp))
if __dbug__ >= 3:
print('connect to : ' + ip_add + ':' + str(udp))
except liblo.AddressError as err:
if __dbug__ >= 3:
print('liblo.AddressError' + str(err))
#msg = liblo.Message('/' + self.address)
msg = liblo.Message(self.address)
if isinstance(self.value, list):
# this is a list of values to send
for arg in self.value:
arg = check_type(arg)
msg.add(arg)
else:
# this is a single value to send
msg.add(self.value)
liblo.send(target, msg)
if __dbug__ >= 3:
print('update ' + self.name + ' to value ' +
str(self.value))
return True
except NoOutputError:
return False
def __init__(self, config, converter):
"""Setup OSC and MQTT servers.
@param config: configuration directory
@param converter: Osc2MqttConverter instance
"""
self.converter = converter
self.config = config
self.mqtt_host, self.mqtt_port = parse_hostport(
config.get("mqtt_broker", "localhost"), 1883)
self.osc_port = int(config.get("osc_port", 9001))
self.osc_receiver = config.get("osc_receiver")
self.subscriptions = config.get("subscriptions", ['#'])
if self.osc_receiver:
host, port = parse_hostport(self.osc_receiver, 9000)
self.osc_receiver = liblo.Address(host, port, liblo.UDP)
self.mqttclient = mqtt.Client(config.get("client_id", "osc2mqtt"))
self.mqttclient.on_connect = self.mqtt_connect
self.mqttclient.on_disconnect = self.mqtt_disconnect
self.mqttclient.on_message = self.handle_mqtt
self.oscserver = liblo.ServerThread(self.osc_port)
self.oscserver.add_method(None, None, self.handle_osc)
def main():
a, bp = dac.find_first_dac()
d = dac.DAC(a)
scale = .35
pps = 20000
target = liblo.Address(a, 60000)
liblo.send(target, "/geom/tl", int(-1), int(1))
liblo.send(target, "/geom/tr", int(1), int(1))
liblo.send(target, "/geom/bl", int(-1), int(-1))
liblo.send(target, "/geom/br", int(1), int(-1))
liblo.send(target, "/geom/pps", pps)
liblo.send(target, "/geom/size", scale)
with open('ildatest.ild', 'rb') as f:
frames = list(readFrames(f))
def stream_points():
while True:
for f in frames:
for p in f.iterPoints():
yield p.encode()
itr = iter(stream_points())
d.play_iter(pps, bp.buffer_capacity, itr)
def init(etc_object):
global osc_server, osc_target, etc
etc = etc_object
# OSC init server and client
try:
osc_target = liblo.Address(4001)
except liblo.AddressError as err:
print("ERROR!" + err)
sys.exit()
try:
osc_server = liblo.Server(4000)
print('OOOOOOOOOOOOOOOOO OSC 0000000000 ')
except liblo.ServerError as err:
print("ERROR!")
print(str(err))
sys.exit()
osc_server.add_method("/knobs", 'iiiiii', knobs_callback)
osc_server.add_method("/key", 'ii', keys_callback)
osc_server.add_method("/mblob", 'b', mblob_callback)
osc_server.add_method("/reload", 'i', reload_callback)
# osc_server.add_method("/new", 's', reload_callback)
osc_server.add_method("/set", 's', set_callback)
osc_server.add_method("/new", 's', new_callback)
osc_server.add_method("/fs", 'i', fs_callback)
osc_server.add_method(None, None, fallback)
def __init__(self, port, client_ip, client_port):
liblo.Server.__init__(self, port)
self.client = liblo.Address(client_ip, client_port)
logger.info('action="init_server", port="%s", client_port="%s"', port,
client_port)
# Allow broadcast to clients
self.socket = socket.fromfd(self.fileno(), socket.AF_INET,
socket.SOCK_DGRAM)
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, True)
self.sound_effects = SoundEffects()
self.water = Water()
self.light = Lighting()
self.systems = {
'sound': {
'sync': self.sound_effects.sync,
'volume': self.sound_effects.volume,
'thunder': self.sound_effects.thunder,
'rain_volume': self.sound_effects.rain_volume,
'its_raining_men': self.sound_effects.its_raining_men,
'silence': self.sound_effects.silence
},
'light': {
'sync': self.light.sync,
'lightning': self.light.strobe,
'cloud_z': self.light.cloud_z,
'cloud_xy': self.light.cloud_xy,
},
'light2': {
'sync': self.light.sync,
'brightness': self.light.brightness,
'contrast': self.light.contrast,
'detail': self.light.detail,
'color_top': self.light.color_top,
'color_bottom': self.light.color_bottom,
'turbulence': self.light.turbulence,
'speed': self.light.speed,
'heading': self.light.heading,
'rotation': self.light.rotation,
},
'light3': {
'loadsave': self.light.loadsave,
},
'smb': {
'sync': self.sound_effects.sync,
'smb_effects': self.sound_effects.smb_sounds,
},
'water': {
'sync': self.water.sync,
'rain': self.water.rain,
'mist': self.water.mist,
'spare': self.water.spare,
'pump': self.water.pump,
'all_rain_off': self.water.all_rain_off,
}
}
def run():
if not args.file:
print("no audio file provided, exiting..")
exit(0)
mplayer_cmd_prefix = "mplayer -ao jack"
if args.offset:
mplayer_cmd_prefix += f" -ss {args.offset}"
mplayer_cmd = mplayer_cmd_prefix + f" {args.file}"
dest = liblo.Address('127.0.0.1', 10000)
osc_server = OscServer()
osc_server.start()
jack_samplerate = int(subprocess.check_output("jack_samplerate", shell=True).decode())
sample_length = int(float(args.length) * float(jack_samplerate))
print('sample_length: ')
print(sample_length)
print('mplayer_cmd: ')
print(mplayer_cmd)
subprocess.Popen(f"./jackdiff -l {sample_length}", shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
subprocess.Popen(f"{mplayer_cmd}", shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
time.sleep(0.1)
make_jack_connections(1, 1)
send_is_ready_msg(dest)
figure, axis = plt.subplots(2)
in_x = []
in_y = []
out_x = []
out_y = []
with open("output/signal_in.txt", "r") as fp:
for index, line in enumerate(fp):
in_x.append(index)
in_y.append(float(line.strip()))
with open("output/signal_out.txt", "r") as fp:
for index, line in enumerate(fp):
out_x.append(index)
out_y.append(float(line.strip()))
axis[0].plot(in_x, in_y)
axis[0].set_title('signal in')
axis[1].plot(out_x, out_y)
axis[1].set_title('signal out')
plt.show()
print('exiting..')
exit(0)
def rec_stop(self):
if len(self.deefuzzer_pid) != 0:
for port in self.deefuzzer_osc_ports:
try:
target = liblo.Address(int(port))
liblo.send(target, '/record', 0)
except:
continue
def __init__(self, host='127.0.0.1', port=1234):
try:
print('OSC: connecting to client %s:%d' % (host, port))
self.target = liblo.Address(host, port)
except Exception as e:
print(e)
print(
'OSC: Could not connect to server ') # %s:%d' % (host, port))
def __init__(self, gui, pedlbrd_address, parent=None):
QThread.__init__(self, parent)
self.s = liblo.Server()
if isinstance(pedlbrd_address, (list, tuple)):
addr = liblo.Address(*pedlbrd_address)
else:
addr = liblo.Address(pedlbrd_address)
self.pedlbrd_address = addr
self.register_osc_methods()
self.s.send(self.pedlbrd_address, '/register')
self.s.send(self.pedlbrd_address, '/registerui')
self.gui = gui
self._heartbeat_counter = 0
self._reply_callbacks = {}
self._last_replyid = 0
self._last_time_anpin = [0, 0, 0, 0]
self._analog_value = [0, 0, 0, 0]
def setNewTarget(newTargetUrl):
ip = re.findall(r'[0-9]+(?:\.[0-9]+){3}', newTargetUrl)
global target
try:
target = liblo.Address(ip[0], defaultReplyPort)
except liblo.AddressError, err:
print str(err)
sys.exit()
class Server:
# send all messages to port 26903 on the local machine
try:
puredata = liblo.Address(26903)
except liblo.AddressError, err:
print str(err)
sys.exit()
def __init__(self, *args, **kwargs):
liblo.Server.__init__(self, *args, **kwargs)
self.freq = [6] * 4
self.ring_map = [0, 1]
self.devices = []
self.spiro = liblo.Address(8989)
self.update_spiro(0)
self.update_spiro(1)
def setup(tcp_port, osc_port):
global tcp_socket, osc_target
# create OSC server address to send OSC data to
try:
osc_target = liblo.Address(osc_port)
except liblo.AddressError, msg:
print 'Failed to create osc address. Error Code: %s | Message: %s' % (
str(msg[0]), str(msg[1]))
sys.exit()
def answer(self, client_address, address, answer, port=33333):
if answer == True:
answer = 1
if answer == False:
answer = 0
target = liblo.Address(client_address, port)
msg = liblo.Message(address)
msg.add(answer)
liblo.send(target, msg)
