def deviceLoop(): inputidx = {} outputsigs = {} args = [] got_new_values = [False] def h(sig, f): if inputidx.has_key(sig.name): args[inputidx[sig.name]] = f got_new_values[0] = True dev = mapper.device("functionMapper", 9000) inplist = set([]) outlist = set([]) while not done: dev.poll(10) if got_new_values[0]: got_new_values[0] = False try: result = processfunc[0](*args) if result.__class__ == int or result.__class__ == float: outs = {'output00': result} elif result.__class__ == list: outs = dict([('output%02d'%i,x) for i,x in enumrate(result)]) elif result.__class__ == dict: outs = result else: outs = {} for o in outs: outputsigs[o].update(result[o]) except Exception, e: print e while not que.empty(): newinplist, newoutlist = que.get() diff = set(newinplist).difference(inplist) inplist.update(newinplist) for n,i in enumerate(newinplist): inputidx['/'+i] = n for i in diff: dev.add_input('/'+i, 1, 'f', None, None, None, h) while len(args) < len(inplist): args.append(0) diff = set(newoutlist).difference(outlist) outlist.update(newoutlist) for o in diff: outputsigs[o] = dev.add_output('/'+o, 1, 'f', None, None, None)
def main(): if pwm.run_synth()==0: print "Error running synth." return try: window = Tkinter.Tk() window.title("libmapper PWM synth demo") name = [False, Tkinter.StringVar()] name[1].set("Waiting for device name...") label = Tkinter.Label(window, textvariable=name[1]) label.pack() gain = Tkinter.Scale(window, from_=0, to=100, label='gain', orient=Tkinter.HORIZONTAL, length=300, command=lambda n: pwm.set_gain(float(n)/100.0)) gain.pack() freq = Tkinter.Scale(window, from_=0, to=1000, label='freq', orient=Tkinter.HORIZONTAL, length=300, command=lambda n: pwm.set_freq(float(n))) freq.pack() duty = Tkinter.Scale(window, from_=0, to=100, label='duty', orient=Tkinter.HORIZONTAL, length=300, command=lambda n: pwm.set_duty(float(n)/100.0)) duty.pack() dev = mapper.device("tk_pwm", 9000) dev.add_input_signal("/gain", 1, 'f', None, 0, 100, lambda s,i,n,t: gain.set(n)) dev.add_input_signal("/freq", 1, 'f', "Hz", 0, 1000, lambda s,i,n,t: freq.set(n)) dev.add_input_signal("/duty", 1, 'f', None, 0, 100, lambda s,i,n,t: duty.set(n)) def do_poll(): dev.poll(0) if not name[0] and dev.ready(): name[0] = True name[1].set('Device name: %s, listening on port %d' %(dev.name, dev.port)) window.after(5, do_poll) do_poll() window.mainloop() finally: pwm.stop_synth()
def __init__(self, hostip, myport, myip, myname, swarmSize, serialPort, serialRate, config, idrange, verbose, apiMode, ignoreUnknown = False, checkXbeeError = False ): self.device = mapper.device("hive", 9000) self.output_signals = [] self.hive = pydonhive.MiniHive( serialPort, serialRate, apiMode, poll = lambda: self.device.poll(5) ) self.hive.set_id_range( idrange[0], idrange[1] ) self.hive.load_from_file( config ) self.hive.set_verbose( verbose ) self.hive.set_ignore_unknown( ignoreUnknown ) self.hive.set_check_xbee_error( checkXbeeError ) self.hive.set_newBeeAction( self.hookBeeToMapper ) self.labelbase = "minibee"
def __init__(self): #flags for program learning states self.learning = 0 self.compute = 0 self.recurrent_flag = False; # default case is a nonrecurrent feedforward network #number of mapper inputs and outputs self.num_inputs = 0 self.num_outputs = 0 self.num_hidden = 0 #For the Mapper Signals self.l_inputs = {} self.l_outputs = {} #For the Artificial Neural Network self.data_input = {} self.data_output = {} self.learnMapperDevice = mapper.device("Implicit_LearnMapper",9002)
def __init__(self, parent, title, size, colour="#DDDDE7"): wx.Frame.__init__(self, parent, -1, title=title, size=size) sizer = wx.BoxSizer(wx.VERTICAL) self.dev = mapper.device("test") pos_y = 20 # y position for labels & slides s_label = 0 # integer which will generate incremented labels signal_id = 0 # this will be used to set the proper mapper signal #TODO: generate list of outputs and get their 'real' names to create the labels - duhhh for i in range(10): # generating lables & slides list self.slider = MyControlSlider(self, -1000, 1000, 0, pos=(45, pos_y), backColour=colour, signal_id=signal_id) sizer.Add(wx.StaticText(self, -1, str(s_label)+".", pos =(20, pos_y)), 0, wx.ALIGN_CENTRE|wx.ALL, 5) s_label += 1 pos_y += 25 signal_id += 1 # mapper poll self.timer = wx.Timer(self) self.Bind(wx.EVT_TIMER, self.OnTimer) self.timer.Start(milliseconds=10, oneShot=False)
def __init__(self): #flags for program learning states self.learning = 0 self.compute = 0 self.recurrent_flag = False # default case is a nonrecurrent feedforward network #number of mapper inputs and outputs self.num_inputs = 0 self.num_outputs = 0 self.num_hidden = 0 #For the Mapper Signals self.l_inputs = {} self.l_outputs = {} #For the Artificial Neural Network self.data_input = {} self.data_output = {} self.learnMapperDevice = mapper.device("Implicit_LearnMapper", 9002)
def OnMenu(self, event): objId = event.Id if objId == 100: self.videoEngine.quit() self.mediagrid.Close() if self.previewMenu.IsChecked() : self.preview.Quit() if self.libmapper.IsChecked(): self.timer.Stop() self.frame.Close() if objId == 101 : if self.secondScreen is not None: if str(platform.system()) == "Linux": w,h = self.secondScreen self.videoEngine.setOutputFullscreen(w,h) command = 'wmctrl -r "pantaliQa-output" -e 1,'+str(self.firstScreen[0])+',0,'+str(self.secondScreen[0])+','+str(self.secondScreen[1])+'' command = os.getcwd()+"/libs/scripts/move.sh " command += str(self.firstScreen[0])+" " command += str(self.secondScreen[0])+" " command += str(self.secondScreen[1]) sleep(0.3) os.system(command) for e in range(0, len(self.layers)): self.videoEngine.setFullscreen(e+1) else: print "no linux" if objId == 102 : if self.libmapper.IsChecked(): print "importing libmapper" try: import mapper self.dev = mapper.device("pantaliQa") self.ActivateSignals() self.timer = wx.Timer(self, id=1) self.Bind(wx.EVT_TIMER, self.OnTimer, self.timer) self.timer.Start(milliseconds=500, oneShot=False) print "lib mapper is running" except Exception, e: print e
#!/usr/bin/env python import Tkinter import sys import mapper def on_gui_change(x): sig_out.update(int(x)) def on_mapper_change(sig, id, x, timetag): w.set(int(x)) dev = mapper.device("tkgui", 9000) sig_in = dev.add_input_signal("/signal0", 1, 'i', None, 0, 100, on_mapper_change) sig_out = dev.add_output_signal("/signal0", 1, 'i', None, 0, 100) master = Tkinter.Tk() master.title("libmapper Python GUI demo") name = Tkinter.StringVar() name.set("Waiting for device name...") name_known = False label = Tkinter.Label(master, textvariable=name) label.pack() w = Tkinter.Scale(master, from_=0, to=100, label='signal0', orient=Tkinter.HORIZONTAL, length=300, command=on_gui_change) w.pack()
#!/usr/bin/env python from __future__ import print_function import sys, mapper, random def h(sig, id, val, timetag): print(' handler got', sig.name, '=', val, 'at time', timetag.get_double()) srcs = [mapper.device("src"), mapper.device("src")] outsigs = [srcs[0].add_output_signal("outsig", 1, 'i'), srcs[1].add_output_signal("outsig", 1, 'i')] dest = mapper.device("dest") insig = dest.add_input_signal("insig", 1, 'f', None, None, None, h) while not srcs[0].ready or not srcs[1].ready or not dest.ready: srcs[0].poll(10) srcs[1].poll(10) dest.poll(10) map = mapper.map(outsigs, insig) if not map: print('error: map not created') else: map.mode = mapper.MODE_EXPRESSION map.expression = "y=x0+x1" map.push() while not map.ready: srcs[0].poll(10) srcs[1].poll(10)
import pygame import mapper pygame.joystick.init() pygame.display.init() # stupid but must init display j = pygame.joystick.Joystick(0) j.init() dev = mapper.device('joystick') sig_button = dev.add_output('/button', 1, 'i', None, 0, 1) sig_x = dev.add_output('/x', 1, 'f', None, -1, 1) sig_y = dev.add_output('/y', 1, 'f', None, -1, 1) sig_yaw = dev.add_output('/yaw', 1, 'f', None, -1, 1) sig_pitch = dev.add_output('/pitch', 1, 'f', None, -1, 1) while True: dev.poll(50) pygame.event.get() sig_button.update(j.get_button(2)) sig_x.update(j.get_axis(0)) sig_y.update(j.get_axis(1)) sig_yaw.update(j.get_axis(2)) sig_pitch.update(j.get_axis(3))
from pyo import * import mapper from random import uniform import time s = Server(audio='jack').boot() s.start() a = BrownNoise() b = Biquadx(a, freq=[200, 400, 800, 1600, 3200, 6400], q=10, type=2).out() def freq_handler(sig, id, val, timetag): try: b.setFreq( val ) except: print 'exception' print sig, val def setup(d): dev_input = dev.add_input( "/Q", 1, "f", None, 1, 5, lambda s, i, f, t: b.setQ(f) ) dev_input = dev.add_input( "/pitch", 1, "f", None, 20, 15000, freq_handler ) dev = mapper.device("biquad") setup(dev) while 1: dev.poll(10)
def libmapper_setup(self, id_number): self.libmapper_dev = mapper.device("T-Stick{0:03d}".format(id_number)) self.libmapper_configured = True
#!/usr/bin/env python from pyo import * import mapper import math s = Server().boot() s.start() duty = SigTo(value=0.5, time=0.5, init=0.5, add=-0.5) freq = SigTo(value=200, time=0.5, init=200) amp = SigTo(value=0.5, time=0.5, init=0.0) p = Phasor(freq=freq, add=Clip(duty, min=-0.5, max=0.5)) sig = DCBlock(Sig(value=Round(p), mul=[amp, amp])).out() try: dev = mapper.device("pyo_pwm_example", 9000) dev.add_input("/frequency", 1, 'f', "Hz", 0, 1000, lambda s, i, n, t: freq.setValue(n)) dev.add_input("/amplitude", 1, 'f', "normalized", 0, 1, lambda s, i, n, t: amp.setValue(n)) dev.add_input("/duty", 1, 'f', "normalized", 0, 1, lambda s, i, n, t: duty.setValue(n)) while True: dev.poll(5) finally: s.stop()
#!/usr/bin/env python import Tkinter import sys import mapper def on_gui_change(x): sig_out.update(int(x)) def on_mapper_change(sig, id, x, timetag): w.set(int(x)) dev = mapper.device("tkgui", 9000) sig_in = dev.add_input("/signal0", 1, 'i', None, 0, 100, on_mapper_change) sig_out = dev.add_output("/signal0", 1, 'i', None, 0, 100) master = Tkinter.Tk() master.title("libmapper Python GUI demo") name = Tkinter.StringVar() name.set("Waiting for device name...") name_known = False label = Tkinter.Label(master, textvariable=name) label.pack() w = Tkinter.Scale(master, from_=0, to=100, label='signal0', orient=Tkinter.HORIZONTAL, length=300, command=on_gui_change) w.pack()
#!/usr/bin/env python import Tkinter, sys, math, mapper N = int(sys.argv[1]) values = [0.5]*N def on_sig(n,v): values[n] = v redraw() dev = mapper.device("octovisualiser") sigs = [dev.add_input_signal("arm.%d"%n, 1, 'f', None, 0.0, 1.0, (lambda n: lambda s,i,f,t: on_sig(n,f))(n)) for n in range(N)] root = Tkinter.Tk() canvas = Tkinter.Canvas(root, width=400, height=400) canvas.pack() def redraw(): canvas.delete("all") radius = 150 for n in range(N): canvas.create_line(200, 200, 200 + math.cos(float(n)/N*2*math.pi)*radius, 200 + math.sin(float(n)/N*2*math.pi)*radius, smooth=1) poly = []
dark1 = DarkAtmosphere() dark2 = DarkAtmosphere() dark3 = DarkAtmosphere() dark4 = DarkAtmosphere() wind = Wind(.5) myfm = MyFM() dark1.out() dark2.out() dark3.out() dark4.out() wind.out() myfm.out() dev1 = mapper.device("Dark") dev2 = mapper.device("Dark") dev3 = mapper.device("Dark") dev4 = mapper.device("Dark") # dev input 1 dev1.add_input( "/pitch1", 1, "f", "Hz", 0, 1, lambda s, i, f, t: dark1.setPitch(f, f*1.01) ) dev1.add_input( "/pitch2", 1, "f", "Hz", 0, 1, lambda s, i, f, t: dark1.setPitch(f, f*1.10) ) dev2.add_input( "/pitch1", 1, "f", "Hz", 0, 1, lambda s, i, f, t: dark2.setPitch(f, f*1.01) ) dev2.add_input( "/pitch2", 1, "f", "Hz", 0, 1, lambda s, i, f, t: dark2.setPitch(f, f*1.10) ) dev3.add_input( "/pitch1", 1, "f", "Hz", 0, 1, lambda s, i, f, t: dark3.setPitch(f, f*1.01) ) dev3.add_input( "/pitch2", 1, "f", "Hz", 0, 1, lambda s, i, f, t: dark3.setPitch(f, f*1.10) ) dev4.add_input( "/pitch1", 1, "f", "Hz", 0, 1, lambda s, i, f, t: dark4.setPitch(f, f*1.01) )
#!/usr/bin/env python import Tkinter import sys import mapper def on_gui_change(x): sig_out.update(int(x)) def on_mapper_change(sig, id, x, timetag): w.set(int(x)) dev = mapper.device("tkgui") sig_in = dev.add_input_signal("signal", 1, 'i', None, 0, 100, on_mapper_change) sig_out = dev.add_output_signal("signal", 1, 'i', None, 0, 100) master = Tkinter.Tk() master.title("libmapper Python GUI demo") name = Tkinter.StringVar() name.set("Waiting for device name...") name_known = False label = Tkinter.Label(master, textvariable=name) label.pack() w = Tkinter.Scale(master, from_=0,
#!/usr/bin/env python from pylab import * from data import gestures_idmil_230811 import operations.display import operations.classifier import features.basic import features.blockbased from minibee import Minibee import serial dev = None try: import mapper dev = mapper.device("minibee",9000) sig_centroid = dev.add_output("/centroid", 'f') sig_slope = dev.add_output("/slope", 'f') except: print 'Continuing without libmapper support.' def stream_block_processor(t,a): """Break up an incoming stream into 1024-sized blocks. Add 16 extra samples to make the block-based analysis pull out a single block properly.""" times = zeros(1024+16) accels = zeros((1024+16,3)) pos = 0 while True: try: times[pos] = t accels[pos] = a
def main(): if pwm.run_synth() == 0: print "Error running synth." return try: window = Tkinter.Tk() window.title("libmapper PWM synth demo") name = [False, Tkinter.StringVar()] name[1].set("Waiting for device name...") label = Tkinter.Label(window, textvariable=name[1]) label.pack() gain = Tkinter.Scale(window, from_=0, to=100, label='gain', orient=Tkinter.HORIZONTAL, length=300, command=lambda n: pwm.set_gain(float(n) / 100.0)) gain.pack() freq = Tkinter.Scale(window, from_=0, to=1000, label='freq', orient=Tkinter.HORIZONTAL, length=300, command=lambda n: pwm.set_freq(float(n))) freq.pack() duty = Tkinter.Scale(window, from_=0, to=100, label='duty', orient=Tkinter.HORIZONTAL, length=300, command=lambda n: pwm.set_duty(float(n) / 100.0)) duty.pack() dev = mapper.device("tk_pwm", 9000) dev.add_input("/gain", 1, 'f', None, 0, 100, lambda s, i, n, t: gain.set(n)) dev.add_input("/freq", 1, 'f', "Hz", 0, 1000, lambda s, i, n, t: freq.set(n)) dev.add_input("/duty", 1, 'f', None, 0, 100, lambda s, i, n, t: duty.set(n)) def do_poll(): dev.poll(0) if not name[0] and dev.ready(): name[0] = True name[1].set('Device name: %s, listening on port %d' % (dev.name, dev.port)) window.after(5, do_poll) do_poll() window.mainloop() finally: pwm.stop_synth()
import mapper def freq_handler(sig, id, val, timetag): pass def setup(d): dev_input = dev.add_input( "/Q", 1, "f", None, 1, 500, lambda s, i, f, t: freq_handler ) dev_input = dev.add_input( "/pitch", 1, "f", None, 20, 15000, freq_handler ) dev_output = dev.add_output( "/x", 1, "f", None, 20, 15000) dev_output = dev.add_output( "/y", 1, "f", None, 20, 15000) dev = mapper.device("device") setup(dev) while 1: dev.poll(10)
#Open Serial Port to Read Data if OS == 'nt': port_list = [14-1,5-1] elif OS == 'posix': import sys sys.path.append("/Users/mahtab-ghamsari/Projects/Mappings/pyserial-2.5/") port_list=['/dev/tty.usbserial-A8004lV1','/dev/tty.usbserial-AD004lUY'] from fungible_board_class import Fungible_Node print Fungible_Node still_alive=1 #root.after(5, ontimer) #root.mainloop() m_inst= mapper.device("Fungible1", 9000) b_array={} b_num=0 b_list=[0,1] open_list=[] for b_num in port_list: try: b_array[b_num]=Fungible_Node(b_num,115200,0.3,m_inst) open_list.append(b_num) except: raise try: q = Queue() print q
elif (len(sys.argv) > 1): print("Bad Input Arguments (#inputs, #hidden nodes, #outputs)") sys.exit(1) else: #number of network inputs num_inputs = 8 #number of network outputs num_outputs = 8 #number of hidden nodes num_hidden = 5 print( "No Input Arguments (#inputs, #hidden nodes, #outputs), defaulting to: " + str(num_inputs) + ", " + str(num_hidden) + ", " + str(num_outputs)) #instatiate mapper l_map = mapper.device("learn_mapper", 9002) l_inputs = {} l_outputs = {} data_input = {} data_output = {} learning = 0 compute = 0 for s_index in range(num_inputs): data_input[s_index] = 0.0 # data_input[s_index+10]=0.0 for s_index in range(num_outputs): data_output[s_index] = 0.0 sliders = {}
from pyo import * import mapper s = Server(audio="jack", sr=44100, buffersize=512).boot() osc_bundle = ['/om1/x', '/om1/y', '/om1/z', '/om2/x', '/om2/y', '/om2/z'] s.start() om1_dev = mapper.device("om") om2_dev = mapper.device("om") om1_x = om1_dev.add_output("/x", 1, 'f', None, -1000, 1000) om1_y = om1_dev.add_output("/y", 1, 'f', None, -1000, 1000) om1_z = om1_dev.add_output("/z", 1, 'f', None, -1000, 1000) om2_x = om2_dev.add_output("/x", 1, 'f', None, -1000, 1000) om2_y = om2_dev.add_output("/y", 1, 'f', None, -1000, 1000) om2_z = om2_dev.add_output("/z", 1, 'f', None, -1000, 1000) def osc_handler(address, args): if address == '/om1/x': print args om1_x.update(args) elif address == '/om1/y':
sys.path.append( os.path.join(os.path.join(os.getcwd(), os.path.dirname(sys.argv[0])), '../../swig')) import mapper except: print 'Error importing libmapper module.' sys.exit(1) s = Server().boot() s.start() duty = SigTo(value=0.5, time=0.5, init=0.5, add=-0.5) freq = SigTo(value=200, time=0.5, init=200) amp = SigTo(value=0.5, time=0.5, init=0.0) p = Phasor(freq=freq, add=Clip(duty, min=-0.5, max=0.5)) sig = DCBlock(Sig(value=Round(p), mul=[amp, amp])).out() try: dev = mapper.device("pyo_pwm_example", 9000) dev.add_input_signal("/frequency", 1, 'f', "Hz", 0, 1000, lambda s,i,n,t: freq.setValue(n)) dev.add_input_signal("/amplitude", 1, 'f', "normalized", 0, 1, lambda s,i,n,t: amp.setValue(n)) dev.add_input_signal("/duty", 1, 'f', "normalized", 0, 1, lambda s,i,n,t: duty.setValue(n)) while True: dev.poll(5) finally: s.stop()
elif (len(sys.argv)>1): print ("Bad Input Arguments (#inputs, #hidden nodes, #outputs)") sys.exit(1) else: #number of network inputs num_inputs=8 #number of network outputs num_outputs=8 #number of hidden nodes num_hidden=5 print ("No Input Arguments (#inputs, #hidden nodes, #outputs), defaulting to: " + str(num_inputs) + ", " + str(num_hidden) + ", " + str(num_outputs) ) #instatiate mapper l_map=mapper.device("learn_mapper",9000) l_inputs={} l_outputs={} l_outputs_derrivatives={} data_input={} data_output={} learning = 0 compute = 0 for s_index in range(num_inputs): data_input[s_index+10]=0.0 # data_input[s_index]=0.0 for s_index in range (num_outputs): data_output[s_index]=0.0
#!/usr/bin/env python from __future__ import print_function import sys, mapper def h(sig, id, f, timetag): try: print('--> received query response:', f) except: print('exception') print(sig, f) src = mapper.device("src") outsig = src.add_output_signal("outsig", 1, 'f', None, 0, 1000) outsig.set_callback(h) dest = mapper.device("dest") insig = dest.add_input_signal("insig", 1, 'f', None, 0, 1, h) while not src.ready or not dest.ready: src.poll() dest.poll(10) map = mapper.map(outsig, insig) map.mode = mapper.MODE_LINEAR map.push() while not map.ready: src.poll(10) dest.poll(10)
def createDevice(self, device_name): self.OSC_dev = mapper.device(device_name) self.OSC_dev.add_output("/x", 1, 'f', None, -1000, 1000) self.OSC_dev.poll(100) self.OSC_devices.append(self.OSC_dev) return self.OSC_dev
print 'signal full name',sig.full_name print 'signal is_output',sig.is_output print 'signal length',sig.length print 'signal type', sig.type print 'signal is_output', sig.is_output print 'signal unit', sig.unit dev.set_properties({"testInt":5, "testFloat":12.7, "testString":"test", 'removed1':"shouldn't see this"}) dev.properties['testInt'] = 7 dev.set_properties({"removed1":None, "removed2":"test"}) dev.remove_property("removed2") print 'signal properties:', sig.properties sig.properties['testInt'] = 3 print 'signal properties:', sig.properties dev = mapper.device("test", 9000) setup(dev) def db_cb(rectype, record, action): print rectype,'callback -' print ' record:',record print ' action:',["MODIFY","NEW","REMOVE"][action] mon = mapper.monitor() mon.db.add_device_callback(lambda x,y:db_cb('device',x,y)) mon.db.add_signal_callback(lambda x,y:db_cb('signal',x,y)) mon.db.add_connection_callback(lambda x,y:db_cb('connection',x,y)) l = lambda x,y:db_cb('link',x,y) mon.db.add_link_callback(l) mon.db.remove_link_callback(l)
except: try: # Try the "swig" directory, relative to the location of this # program, which is where it should be if the module has been # compiled but not installed. sys.path.append( os.path.join(os.path.join(os.getcwd(), os.path.dirname(sys.argv[0])), '../swig')) import mapper except: print 'Error importing libmapper module.' sys.exit(1) numsliders = 3 dev = mapper.device("pysideGUI") #dev.set_map_callback(h) sigs = [] for i in range(numsliders): sigs.append(dev.add_output_signal('/slider%i' %i, 1, 'f', None, 0, 1)) class gui(QMainWindow): def __init__(self): QMainWindow.__init__(self) self.setGeometry(300, 300, 300, 300) self.setFixedSize(300, 300) self.setWindowTitle('libmapper device gui example') blurb = QLabel('These sliders will be dynamically labeled with the name of destination signals to which they are connected.', self) blurb.setGeometry(5, 0, 290, 50) blurb.setWordWrap(True)
#!/usr/bin/env python import sys, mapper def h(sig, id, f, timetag): try: print 'received query response:', f except: print 'exception' print sig, f src = mapper.device("src", 9000) outsig = src.add_output("/outsig", 1, 'f', None, 0, 1000) outsig.set_query_callback(h) dest = mapper.device("dest", 9000) insig = dest.add_input("/insig", 1, 'f', None, 0, 1) while not src.ready() or not dest.ready(): src.poll() dest.poll(10) monitor = mapper.monitor() monitor.link('%s' %src.name, '%s' %dest.name) monitor.connect('%s%s' %(src.name, outsig.name), '%s%s' %(dest.name, insig.name), {'mode': mapper.MO_LINEAR}) for i in range(100): insig.update(i)
from pyo import * import mapper synth = Server().boot().start() dev = mapper.device("synthesizer") snd = SndTable("/Users/lyang/libmapper/cyborg/sound.wav") env = HannTable() g = Granulator(snd, env, pitch=1, pos=0, dur=1, grains=24, mul=.5).out() e = Adsr(attack=2, decay=0, sustain=1, release=2, mul=.1) e_playing = False noise = PinkNoise(mul=e).mix(2).out() def noise_handler(sig, id, val, timetag): global e_playing if val == 1 and not e_playing: e.play() e_playing = True elif val == 0 and e_playing: e.stop() e_playing = False def size_handler(sig, id, val, timetag): g.setDur(val / 1000.0) def pitch_handler(sig, id, val, timetag): g.setPitch(val) def pos_handler(sig, id, val, timetag): g.setPos(val) dev.add_input( '/noise_on', 1, 'i', None, 0, 1, noise_handler) dev.add_input('/grain_size', 1, 'f', 'ms', 50, 700, size_handler)
def __init__(self, instrument_name): self.libmapper_dev = mapper.device(instrument_name)
#!/usr/bin/env python import Tkinter import sys import mapper def on_gui_change(x): sig_out.update(int(x)) def on_mapper_change(sig, id, x, timetag): w.set(int(x)) dev = mapper.device("tkgui") sig_in = dev.add_input_signal("signal", 1, 'i', None, 0, 100, on_mapper_change) sig_out = dev.add_output_signal("signal", 1, 'i', None, 0, 100) master = Tkinter.Tk() master.title("libmapper Python GUI demo") name = Tkinter.StringVar() name.set("Waiting for device name...") name_known = False label = Tkinter.Label(master, textvariable=name) label.pack() w = Tkinter.Scale(master, from_=0, to=100, label='signal0', orient=Tkinter.HORIZONTAL, length=300, command=on_gui_change) w.pack()
sig.minimum = 12 print 'signal minimum', sig.minimum sig.minimum = None print 'signal minimum', sig.minimum sig.properties['testInt'] = 3 print 'signal properties:', sig.properties d.add_input_signal("insig", 4, 'f', None, None, None, h) d.add_output_signal("outsig", 4, 'f') print 'setup done!' #check libmapper version print 'using libmapper version', mapper.version dev = mapper.device("test") setup(dev) def database_cb(rectype, record, action): print rectype,["ADDED", "MODIFIED", "REMOVED", "EXPIRED"][action],'callback' if rectype is 'device': print ' ', record.name db = mapper.database(subscribe_flags=mapper.OBJ_ALL) db.add_device_callback(lambda x,y:database_cb('device',x,y)) db.add_signal_callback(lambda x,y:database_cb('signal',x,y)) db.add_map_callback(lambda x,y:database_cb('map',x,y)) while not dev.ready(): dev.poll(10)
sig.minimum = 12 print('signal minimum', sig.minimum) sig.minimum = None print('signal minimum', sig.minimum) sig.properties['testInt'] = 3 print('signal properties:', sig.properties) d.add_input_signal("insig", 4, 'f', None, None, None, h) d.add_output_signal("outsig", 4, 'f') print('setup done!') #check libmapper version print('using libmapper version', mapper.version) dev = mapper.device("test") setup(dev) def database_cb(rectype, record, action): print(rectype,["ADDED", "MODIFIED", "REMOVED", "EXPIRED"][action],'callback') if rectype is 'device': print(' ', record.name) db = mapper.database(subscribe_flags=mapper.OBJ_ALL) db.add_device_callback(lambda x,y:database_cb('device',x,y)) db.add_signal_callback(lambda x,y:database_cb('signal',x,y)) db.add_map_callback(lambda x,y:database_cb('map',x,y)) while not dev.ready: dev.poll(10)
#!/usr/bin/env python import mapper, sys import math # function to receive a signal through libmapper def h(sig, id, f, timetag): try: print sig.name, f except: print 'exception' print sig, f dev = mapper.device("Lyrabox", 9000) sig1 = dev.add_output("/button", 1, 'i', None, 0, 1) sig2 = dev.add_output("/switch1", 1, 'i', None, 0, 1) sig3 = dev.add_output("/switch2", 1, 'i', None, 0, 1) sig4 = dev.add_output("/encoder", 1, 'i', None, 0, 1) sig5 = dev.add_output("/enc_button", 1, 'i', None, 0, 1) sig6 = dev.add_output("/analog_sensor0", 1, 'f', None, 0, 1024) sig_in = dev.add_input("/led", 1, 'i', "normalized", 0, 1, h) # function to update the libmapper signal # usage: signal number (int), sinal value (whatever is in range) def updateSignal(signal, value): if signal==1: sig1.update(value) if signal==2: sig2.update(value)
import mapper dev = mapper.device("test_sender") sensor1 = dev.add_output_signal("sensor1", 1, 'f', "V", 0.0, 2000.0) counter = 0 while 1: dev.poll(50) counter += 1 print(counter) sensor1.update(counter) if counter > 1999: counter = 0
except: try: # Try the "swig" directory, relative to the location of this # program, which is where it should be if the module has been # compiled but not installed. sys.path.append( os.path.join( os.path.join(os.getcwd(), os.path.dirname(sys.argv[0])), '../swig')) import mapper except: print 'Error importing libmapper module.' sys.exit(1) numsliders = 3 dev = mapper.device("pysideGUI") sigs = [] for i in range(numsliders): sigs.append(dev.add_output_signal('slider%i' % i, 1, 'f', None, 0, 1)) class gui(QMainWindow): def __init__(self): QMainWindow.__init__(self) self.setGeometry(300, 300, 300, 300) self.setFixedSize(300, 300) self.setWindowTitle('libmapper device gui example') blurb = QLabel( 'These sliders will be dynamically labeled with the name of destination signals to which they are connected.', self) blurb.setGeometry(5, 0, 290, 50)
root.mainloop() ################################################# #Open Serial Port to Read Data OS = os.name if os.name == 'nt': port_list = [14-1,5-1,6-1] elif os.name == 'posix': port_list=['/dev/tty.usbserial-A8004lUY','/dev/tty.usbserial-A8004lUZ','/dev/tty.usbserial-A8004lV1'] from fungible_board_class import Fungible_Node print 'Fungible Node',Fungible_Node m_device = mapper.device("Fungible1", 9000) print "MAPPER DEVICE", m_device b_array = {} b_num = 0 #b_list=[0,1,2] b_list = [2] open_list=[] for b_num in b_list: try: b_array[b_num]=Fungible_Node(port_list[b_num],115200,0.3,m_device) open_list.append(b_num) Num_Sigs = b_array[b_num].get_number_of_signals() except: print ("error on b_num",b_num, port_list[b_num])
#!/usr/bin/env python import sys, mapper, random def h(sig, id, f, timetag): print ' handler got', sig.name, '=', f, 'at time', timetag src = mapper.device("src") outsig1 = src.add_output("/outsig1", 1, 'f', None, 0, 1000) outsig2 = src.add_output("/outsig2", 1, 'f', None, 0, 1000) dest = mapper.device("dest") insig1 = dest.add_input("/insig1", 1, 'i', None, 0, 1, h) insig2 = dest.add_input("/insig2", 1, 'i', None, 0, 1, h) while not src.ready() or not dest.ready(): src.poll() dest.poll(10) monitor = mapper.monitor() monitor.link('%s' %src.name, '%s' %dest.name) monitor.connect('%s%s' %(src.name, outsig1.name), '%s%s' %(dest.name, insig1.name), {'mode': mapper.MO_LINEAR}) monitor.connect('%s%s' %(src.name, outsig2.name), '%s%s' %(dest.name, insig2.name), {'mode': mapper.MO_LINEAR}) monitor.poll() for i in range(10):
#!/usr/bin/env python from __future__ import print_function import sys, mapper, random def h(sig, id, val, timetag): print(' handler got', sig.name, '=', val, 'at time', timetag.get_double()) srcs = [mapper.device("src"), mapper.device("src")] outsigs = [ srcs[0].add_output_signal("outsig", 1, 'i'), srcs[1].add_output_signal("outsig", 1, 'i') ] dest = mapper.device("dest") insig = dest.add_input_signal("insig", 1, 'f', None, None, None, h) while not srcs[0].ready or not srcs[1].ready or not dest.ready: srcs[0].poll(10) srcs[1].poll(10) dest.poll(10) map = mapper.map(outsigs, insig) if not map: print('error: map not created') else: map.mode = mapper.MODE_EXPRESSION map.expression = "y=x0+x1" map.push()