Merge branch 'dev' into feature_plugins

actions.py

@@ -231,14 +231,14 @@ class Actions(object):
     def increase_seek_time(self):
         options = self.data.settings['sampler']['SEEK_TIME']['options']
         current_index = [index for index, item in enumerate(options) if item == self.data.settings['sampler']['SEEK_TIME']['value'] ][0]
-        self.data.settings['sampler']['SEEK_TIME']['value'] = options[(current_index + 1) % len(options) ]
+        self.data.update_setting_value('sampler', 'SEEK_TIME', options[(current_index + 1) % len(options) ])
         self.message_handler.set_message('INFO', 'The Seek Time is now ' + str(self.data.settings['sampler']['SEEK_TIME']['value']) + 's')
 
 
     def decrease_seek_time(self):
         options = self.data.settings['sampler']['SEEK_TIME']['options']
         current_index = [index for index, item in enumerate(options) if item == self.data.settings['sampler']['SEEK_TIME']['value'] ][0]
-        self.data.settings['sampler']['SEEK_TIME']['value'] = options[(current_index - 1)  % len(options) ]
+        self.data.update_setting_value('sampler', 'SEEK_TIME', options[(current_index - 1) % len(options) ])
         self.message_handler.set_message('INFO', 'The Seek Time is now ' + str(self.data.settings['sampler']['SEEK_TIME']['value']) + 's')
         
 
@@ -580,7 +580,7 @@ class Actions(object):
         if self.data.settings['shader']['STROBE_AMOUNT']['value'] != scaled_amount:
             print(scaled_amount)
             self.video_driver.osc_client.send_message("/set_strobe", scaled_amount)
-            self.data.settings['shader']['STROBE_AMOUNT']['value'] = scaled_amount
+            self.data.update_setting_value('shader', 'STROBE_AMOUNT', scaled_amount)
 
     def get_midi_status(self):
         device_name = 'none' if not hasattr(self.data,'midi_device_name') else self.data.midi_device_name
@@ -794,16 +794,15 @@ class Actions(object):
     def increase_shader_param(self):
         options = self.data.settings['shader']['SHADER_PARAM']['options']
         current_index = [index for index, item in enumerate(options) if item == self.data.settings['shader']['SHADER_PARAM']['value'] ][0]
-        self.data.settings['shader']['SHADER_PARAM']['value'] = options[(current_index + 1) % len(options) ]
+        self.data.update_setting_value('shader', 'SHADER_PARAM', options[(current_index + 1) % len(options) ])
         self.message_handler.set_message('INFO', 'The Param amount is now ' + str(self.data.settings['shader']['SHADER_PARAM']['value']))
 
     def decrease_shader_param(self):
         options = self.data.settings['shader']['SHADER_PARAM']['options']
         current_index = [index for index, item in enumerate(options) if item == self.data.settings['shader']['SHADER_PARAM']['value'] ][0]
-        self.data.settings['shader']['SHADER_PARAM']['value'] = options[(current_index - 1) % len(options) ]
+        self.data.update_setting_value('shader', 'SHADER_PARAM', options[(current_index - 1) % len(options) ])
         self.message_handler.set_message('INFO', 'The Param amount is now ' + str(self.data.settings['shader']['SHADER_PARAM']['value']))
 
-
     def set_fixed_length(self, value):
         self.data.control_mode = 'LENGTH_SET'
         self.message_handler.set_message('INFO', 'tap: ■ ;   < > : back')
@@ -875,19 +874,22 @@ class Actions(object):
         self.server.shutdown()
 
     def create_client_and_shutdown_osc_server(self):
-        from pythonosc import udp_client
+        try:
-        client_parser = argparse.ArgumentParser()
+            from pythonosc import udp_client
-        client_parser.add_argument("--ip", default=self.data.get_ip_for_osc_client(), help="the ip")
+            client_parser = argparse.ArgumentParser()
-        client_parser.add_argument("--port", type=int, default=8080, help="the port")
+            client_parser.add_argument("--ip", default=self.data.get_ip_for_osc_client(), help="the ip")
+            client_parser.add_argument("--port", type=int, default=8080, help="the port")
 
-        client_args = client_parser.parse_args()
+            client_args = client_parser.parse_args()
 
-        client = udp_client.SimpleUDPClient(client_args.ip, client_args.port)
+            client = udp_client.SimpleUDPClient(client_args.ip, client_args.port)
-        client.send_message("/shutdown", True)
+            client.send_message("/shutdown", True)
+        except:
+            pass
 
     def toggle_access_point(self, setting_value):
         osc_setting_state = self.data.settings['user_input']['OSC_INPUT']['value']
-        self.data.settings['user_input']['OSC_INPUT']['value'] = 'disabled'
+        self.data.update_setting_value('user_input', 'OSC_INPUT', 'disabled') 
         self.tk.after(2000, self.toggle_access_point_delay, setting_value, osc_setting_state)
 
     def toggle_access_point_delay(self, setting_value, osc_setting_state ):
@@ -899,7 +901,7 @@ class Actions(object):
 
     def toggle_remote_server(self, setting_value):
         osc_setting_state = self.data.settings['user_input']['OSC_INPUT']['value']
-        self.data.settings['user_input']['OSC_INPUT']['value'] = 'disabled'
+        self.data.update_setting_value('user_input', 'OSC_INPUT', 'disabled')
         self.tk.after(2000, self.toggle_remote_server_delay, setting_value, osc_setting_state)
 
     def toggle_remote_server_delay(self, setting_value, osc_setting_state):
@@ -907,10 +909,10 @@ class Actions(object):
             self.remote_process = subprocess.Popen(['node', '/home/pi/r_e_m_o_t_e/webserver.js'])
         else:
             self.stop_remote_process()
-        self.data.settings['user_input']['OSC_INPUT']['value'] = osc_setting_state
+        self.data.update_setting_value('user_input', 'OSC_INPUT', osc_setting_state)
 
     def enable_osc(self, osc_setting_state):
-        self.data.settings['user_input']['OSC_INPUT']['value'] = osc_setting_state
+        self.data.update_setting_value('user_input', 'OSC_INPUT', osc_setting_state)
 
 
     def show_ip(self, *args):

data_centre/data.py

@@ -217,7 +217,7 @@ class Data(object):
         tag = tree.find("delayMode")
         tag.text = str(int(value))
         tree.write(self.PATH_TO_CONJUR_DATA)
-    
+
     def get_setting_and_folder_from_name(self, setting_name):
         for folder_key , folder_item in self.settings.items():
             for setting_key, setting_item in folder_item.items():

user_input/midi_input.py

@@ -59,38 +59,30 @@ class MidiInput(object):
     def poll_midi_input(self):
         i = 0
         cc_dict = dict()
-        for message in self.midi_device.iter_pending():
+        midi_channel = self.data.settings['user_input']['MIDI_CHANNEL']['value'] - 1
-            i = i + 1
-            message_dict = message.dict()
-            midi_channel = midi_setting = self.data.settings['user_input']['MIDI_CHANNEL']['value'] - 1
 
-            if not message_dict.get('channel', None) == midi_channel:
+        current_message_buffer = [i.dict() for i in self.midi_device.iter_pending()]
-                pass
+
-            ## turning off noisey clock messages for now - may want to use them at some point
+        refined_buffer = []
-            elif message_dict['type'] == 'clock':
+        #refine buffer from lastest messages first
-                pass
+        current_message_buffer.reverse()
-            ## trying to only let through step cc messages to increase response time
+        for message in current_message_buffer:
-            elif message_dict['type'] == 'control_change':
+            # discard notes from wrong channel
-                control_number = message_dict['control']
+            if message.get('channel') != midi_channel:
-                print('control number is {} , cc_dict.keys is {}'.format(control_number, cc_dict.keys() ))
+                pass
-                if not control_number in cc_dict.keys():
+            # process all note messages (in order)
-                    cc_dict[control_number] = message_dict['value']
+            if 'note' in message['type']:
-                    self.on_midi_message(message_dict)
+                refined_buffer.append(message)
-                else:
+            # only take the latest cc message per cc_channel
-                    step_size = 3
+            elif message['type'] == 'control_change':
-                    ignore_range = range(cc_dict[control_number] - step_size,cc_dict[control_number] + step_size)
+                if not message['control'] in [i.get('control') for i in refined_buffer]:
-                    #print('value is {} and ignore range is {}'.format(message_dict['value'], ignore_range ))
+                    refined_buffer.append(message)
-                    if not message_dict['value'] in ignore_range:
+        # process buffer from oldest messages first
-                        cc_dict[control_number] = message_dict['value']
+        refined_buffer.reverse()
-                        #print(message_dict)
+
-                        self.on_midi_message(message_dict)
+        for message in refined_buffer:
-                    #print(cc_dict)
+            self.on_midi_message(message)
 
-            else:
-                print(message_dict)       
-                self.on_midi_message(message_dict)
-        if i > 0:
-            pass
             #print('the number processed {}'.format(i))
         if self.data.settings['user_input']['MIDI_INPUT']['value'] == self.midi_setting and self.data.midi_port_index == self.port_index:
             self.root.after(self.midi_delay, self.poll_midi_input)
@@ -140,7 +132,12 @@ class MidiInput(object):
             
         else:
             norm_message_value = None
-        self.actions.call_method_name(method_name, norm_message_value)
+        try:
+            self.actions.call_method_name(method_name, norm_message_value)
+        except TypeError:
+            ## to support using cc-0 as button presses
+            if norm_message_value == 0:
+                self.actions.call_method_name(method_name, None)
         ## only update screen if not continuous - seeing if cc can respond faster if not refreshing screen on every action
         if 'continuous' not in message_name:
             self.display.refresh_display()

user_input/osc_input.py

@@ -36,7 +36,9 @@ class OscInput(object):
 
     def setup_osc_server(self):
         ip_address = self.data.get_ip_for_osc_client()
-
+        if ip_address == 'none':
+            self.message_handler.set_message('INFO', 'osc failed - could not find ip')            
+            return
         print('%%%%%%%%%%%%%%%%%%%%% setting up external_osc on ', ip_address)
         server_parser = argparse.ArgumentParser()
         server_parser.add_argument("--ip", default=ip_address, help="the ip")
@@ -46,28 +48,40 @@ class OscInput(object):
 
         this_dispatcher = dispatcher.Dispatcher()
         
-        this_dispatcher.map("/keyboard/*", self.on_osc_input)
+#        this_dispatcher.map("/keyboard/*", self.on_osc_input)
-        this_dispatcher.map("/shaderparam0", self.on_param_osc_input)
+#        this_dispatcher.map("/shaderparam0", self.on_param_osc_input)
-        this_dispatcher.map("/shaderparam1", self.on_param_osc_input)
+#        this_dispatcher.map("/shaderparam1", self.on_param_osc_input)
-        this_dispatcher.map("/shaderparam2", self.on_param_osc_input)
+#        this_dispatcher.map("/shaderparam2", self.on_param_osc_input)
-        this_dispatcher.map("/shaderparam3", self.on_param_osc_input)
+#        this_dispatcher.map("/shaderparam3", self.on_param_osc_input)
-        this_dispatcher.map("/shutdown", self.exit_osc_server)
+#        this_dispatcher.map("/shutdown", self.exit_osc_server)
-
+        this_dispatcher.map("/*", self.on_osc_input)
-        # this is for accepting any old osc message to allow binding of modulation to osc messages
-        # TODO: make configurable?
-        #this_dispatcher.map("/*", self.on_param_osc_input)
         
         osc_server.ThreadingOSCUDPServer.allow_reuse_address = True
         server = osc_server.ThreadingOSCUDPServer((server_args.ip, server_args.port), this_dispatcher)
         server_thread = threading.Thread(target=server.serve_forever)
         server_thread.start()
         self.osc_server = server
+        self.message_handler.set_message('INFO', 'osc active on ' + ip_address)
 
     def exit_osc_server(self, unused_addr, args):
         print('%%%%%%%%%%%%%%%%%%%%% exiting external_osc')
-        self.osc_server.shutdown()
+        try:
+            self.osc_server.shutdown()
+            self.message_handler.set_message('INFO', 'osc deactive')
+        except:
+            self.message_handler.set_message('INFO', 'osc shutdown failed')
+        
 
     def on_osc_input(self, addr, args):
+        if 'keyboard' in addr:
+            self.on_key_osc_input(addr, args)
+        elif 'shutdown' in addr:
+            self.exit_osc_server(addr, args)
+        else:
+            self.on_param_osc_input(addr,args)
+
+
+    def on_key_osc_input(self, addr, args):
         args = str(args)
         print("!!!!!!!!!!!!!!!!" + args)
         print("the address", addr)