merge with dev

actions.py

@@ -29,6 +29,7 @@ class Actions(object):
         self.capture = None
         self.serial_port_process = None
         self.openframeworks_process = None
+        self.remote_process = None
         self.set_capture_object('value')
         self.server = self.setup_osc_server()
         
@@ -47,6 +48,13 @@ class Actions(object):
     def move_browser_selection_up(self):
         self.display.browser_menu.navigate_menu_up()
 
+    def move_browser_selection_page_down(self):
+        self.display.browser_menu.navigate_menu_page_down()
+
+    def move_browser_selection_page_up(self):
+        self.display.browser_menu.navigate_menu_page_up()
+
+
     def enter_on_browser_selection(self):
         self.display.browser_menu.enter_on_browser_selection()
 
@@ -56,6 +64,13 @@ class Actions(object):
     def move_settings_selection_up(self):
         self.display.settings_menu.navigate_menu_up()
 
+    def move_settings_selection_page_down(self):
+        self.display.settings_menu.navigate_menu_page_down()
+
+    def move_settings_selection_page_up(self):
+        self.display.settings_menu.navigate_menu_page_up()
+
+
     def enter_on_settings_selection(self):
         is_setting, setting = self.display.settings_menu.enter_on_setting_selection()
         if is_setting:
@@ -71,6 +86,13 @@ class Actions(object):
     def move_shaders_selection_up(self):
         self.shaders.shaders_menu.navigate_menu_up()
 
+    def move_shaders_selection_page_down(self):
+        self.shaders.shaders_menu.navigate_menu_page_down()
+
+    def move_shaders_selection_page_up(self):
+        self.shaders.shaders_menu.navigate_menu_page_up()
+
+
     def enter_on_shaders_selection(self):
         ##want to select shader if its not selected, and want to enter 'param' mode if it already is
         is_shader, is_selected_shader, selected_shader = self.shaders.enter_on_shaders_selection()
@@ -709,8 +731,10 @@ class Actions(object):
         self.video_driver.exit_all_players()
         self.exit_openframeworks()
         self.exit_osc_server('','')
+        self.create_client_and_shutdown_osc_server()
         self.stop_serial_port_process()
         self.stop_openframeworks_process()
+        self.stop_remote_process()
         self.toggle_x_autorepeat()
         self.tk.destroy()
 
@@ -808,14 +832,59 @@ class Actions(object):
         this_dispatcher.map("/shutdown", self.exit_osc_server)
         #this_dispatcher.map("/player/a/status", self.set_status)
 
+        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()
         return server
 
     def exit_osc_server(self, unused_addr, args):
+        print('shutting down of osc server')
         self.server.shutdown()
 
+    def create_client_and_shutdown_osc_server(self):
+        from pythonosc import udp_client
+        client_parser = argparse.ArgumentParser()
+        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 = udp_client.SimpleUDPClient(client_args.ip, client_args.port)
+        client.send_message("/shutdown", True)
+
+    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.tk.after(2000, self.toggle_access_point_delay, setting_value, osc_setting_state)
+
+    def toggle_access_point_delay(self, setting_value, osc_setting_state ):
+        if setting_value == 'enabled':
+            subprocess.call(['sudo', 'bash', '/home/pi/raspiApWlanScripts/switchToAP.sh'])
+        else:
+            subprocess.call(['sudo', 'bash', '/home/pi/raspiApWlanScripts/switchToWlan.sh'])
+        self.tk.after(6000, self.enable_osc, osc_setting_state)
+
+    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.tk.after(2000, self.toggle_remote_server_delay, setting_value, osc_setting_state)
+
+    def toggle_remote_server_delay(self, setting_value, osc_setting_state):
+        if setting_value == 'enabled':
+            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
+
+    def enable_osc(self, osc_setting_state):
+        self.data.settings['user_input']['OSC_INPUT']['value'] = osc_setting_state
+
+
+    def show_ip(self, *args):
+        address = self.data.get_ip_address()
+        self.message_handler.set_message('INFO', 'ip is {}:8080'.format(address))
+
     def create_serial_port_process(self):
         if self.serial_port_process == None:
             self.serial_port_process = subprocess.Popen("exec " + "ttymidi -s /dev/serial0 -b 38400 -n serial", shell=True)
@@ -826,6 +895,12 @@ class Actions(object):
             self.serial_port_process.kill()
             self.serial_port_process = None
 
+
+    def stop_remote_process(self):
+        if self.remote_process is not None:
+            self.remote_process.kill()
+            self.remote_process = None
+
     def restart_openframeworks(self):
         self.reset_players()
         self.exit_openframeworks()
@@ -904,6 +979,11 @@ class Actions(object):
         if os.path.exists(path):
             os.remove(path)
 
+    def eject_all_usb_drives(self):
+        for i in range(1, 4):
+            if os.path.exists('/dev/sda{}'.format(i)):
+                subprocess.call(['sudo', 'eject', '/dev/sda{}'.format(i)])                
+
     # TODO: make this interrogate the various components for available routes to parse
     # this would include eg a custom script module..
     @property

data_centre/data.py

@@ -1,3 +1,4 @@
+import subprocess
 import json
 import xml.etree.ElementTree as ET
 import os
@@ -91,6 +92,7 @@ class Data(object):
 
         if os.path.isfile(self.PATH_TO_DATA_OBJECTS + self.SETTINGS_JSON):
             self.settings = self._read_json(self.SETTINGS_JSON)
+            self.settings['user_input']['REMOTE_SERVER']['value'] = 'disabled' # remote server off at boot
 
         self.key_mappings = self._read_json(self.KEYPAD_MAPPING_JSON)
         self.osc_mappings = self._read_json(self.OSC_MAPPING_JSON)
@@ -120,6 +122,19 @@ class Data(object):
             self.midi_mappings = self._read_json(self.MIDI_MAPPING_JSON)
         return self.midi_mappings
         
+    def get_ip_address(self):
+        ip_list = subprocess.check_output(['hostname', '-I']).decode('utf-8').split()
+        if len(ip_list) > 0:
+            return ip_list[0]
+        else:
+            return 'none'
+
+    def get_ip_for_osc_client(self):
+        if self.settings['user_input']['REMOTE_SERVER']['value'] == 'enabled':
+            return '127.0.0.1'
+        else:
+            return self.get_ip_address()
+        
     @staticmethod
     def create_empty_bank():
         empty_slot = dict(name='', location='', length=-1, start=-1, end=-1, rate=1)
@@ -473,3 +488,5 @@ class Data(object):
     def try_remove_file(path):
         if os.path.exists(path):
             os.remove(path)
+
+

display_centre/display.py

@@ -146,7 +146,7 @@ class Display(object):
                 self.display_text.insert(END, '{:40} {:5} \n'.format(path['name'][0:38], path['slot']))
                 number_of_lines_displayed = number_of_lines_displayed + 1
 
-        for index in range(self.MENU_HEIGHT - number_of_browser_items):
+        for index in range(self.browser_menu.top_menu_index + self.browser_menu.menu_height - number_of_browser_items):
             self.display_text.insert(END, '\n')
 
         self._highlight_this_row(self.browser_menu.selected_list_index - self.browser_menu.top_menu_index)
@@ -166,7 +166,7 @@ class Display(object):
                 self.display_text.insert(END, '{:<23} {:<22} \n'.format(setting['name'][0:22], setting['value']))
                 line_count = line_count + 1
 
-        for index in range(self.MENU_HEIGHT - number_of_settings_items):
+        for index in range(self.settings_menu.top_menu_index + self.settings_menu.menu_height - number_of_settings_items):
             self.display_text.insert(END, '\n')
 
         self._highlight_this_row(self.settings_menu.selected_list_index - self.settings_menu.top_menu_index)
@@ -197,8 +197,10 @@ class Display(object):
                 shader_line = shaders_list[index]
                 self.display_text.insert(END, '{:<40} {:<5} \n'.format(shader_line['name'][0:30], shader_line['shad_type']))
                 line_count = line_count + 1
-        for index in range(self.MENU_HEIGHT - number_of_shader_items):
+
+        for index in range(self.shaders.shaders_menu.top_menu_index + self.shaders.shaders_menu.menu_height - number_of_shader_items):
             self.display_text.insert(END, '\n')        
+
         self._highlight_this_row(self.shaders.shaders_menu.selected_list_index - self.shaders.shaders_menu.top_menu_index)
         if self.data.control_mode == "SHADER_PARAM":
             self._highlight_this_param(self.shaders.focused_param)

display_centre/menu.py

@@ -23,6 +23,15 @@ class Menu(object):
             if self.top_menu_index < 0:
                 self.top_menu_index = 0
 
+    def navigate_menu_page_up(self):
+        if self.top_menu_index < self.menu_height:
+            self.top_menu_index = 0
+            self.selected_list_index = 0
+        else: 
+            self.top_menu_index -= self.menu_height
+            self.selected_list_index -= self.menu_height
+        print('self.top_menu_index ', self.top_menu_index)
+
     def navigate_menu_down(self):
         last_list_index = len(self.menu_list) - 1
         if self.selected_list_index != last_list_index:
@@ -34,6 +43,14 @@ class Menu(object):
             self.top_menu_index = 0
             self.selected_list_index = self.top_menu_index
 
+    def navigate_menu_page_down(self):
+        if self.top_menu_index >= len(self.menu_list) - self.menu_height:
+            self.selected_list_index = (len(self.menu_list) - 1)
+        else:
+            self.top_menu_index += self.menu_height
+            self.selected_list_index = min(self.menu_height + self.selected_list_index, len(self.menu_list) - 1)
+
+        
     def update_open_folders(self, folder_name):
         if folder_name not in self.open_folders:
             self.open_folders.append(folder_name)
@@ -119,7 +136,7 @@ class SettingsMenu(Menu):
     FOLDER_ORDER = ['video', 'sampler', 'user_input', 'capture', 'shader', 'detour', 'system' ]
     SAMPLER_ORDER = ['LOOP_TYPE', 'LOAD_NEXT', 'RAND_START_MODE', 'RESET_PLAYERS', 'FIXED_LENGTH_MODE', 'FIXED_LENGTH', 'FIXED_LENGTH_MULTIPLY' ]
     VIDEO_ORDER = ['VIDEOPLAYER_BACKEND']
-    USER_INPUT_ORDER = ['MIDI_INPUT', 'MIDI_STATUS', 'CYCLE_MIDI_PORT']
+    USER_INPUT_ORDER = ['MIDI_INPUT', 'MIDI_STATUS', 'CYCLE_MIDI_PORT', 'OSC_INPUT', 'ACCESS_POINT', 'REMOTE_SERVER', 'SHOW_IP' ]
     CAPTURE_ORDER = ['DEVICE', 'TYPE']
     SHADER_ORDER = ['USER_SHADER']
     DETOUR_ORDER = ['TRY_DEMO']

dotfiles/README.md

@@ -183,7 +183,33 @@ dtoverlay=pi3-miniuart-bt
 dtoverlay=midi-uart0
 ```
 
+## updates for v2.2 :
 
+### install AccessPoint switching repo :
+
+- `git clone https://github.com/Autodrop3d/raspiApWlanScripts.git`
+- then run the setup script with correct wlan name / password , and the setup for access-point :
+`sudo bash raspiApWlanScripts/setup_wlan_and_AP_modes.sh -s <your wifi name> -p <your wifi password> -a r_e_c_u_r -r cyberboy666`
+- remove wifi and password from wpa_supplicant.conf since now it reads from wpa_supplicant-wlan.conf ,,
+
+### install and setup node server for remote access/control
+
+- `git clone https://github.com/guergana/r_e_m_o_t_e.git`
+- download node `wget https://nodejs.org/dist/latest-v10.x/node-v10.17.0-linux-armv6l.tar.gz`
+- extract files `tar -xzf node-v10.17.0-linux-armv6l.tar.gz`
+
+Finally copy node to its final location and expose it as a global command:
+
+```
+cd node-v6.11.1-linux-armv6l/
+sudo cp -R * /usr/local/
+```
+- noe `cd r_e_m_o_t_e/`
+- now install sockets `npm install socket.io --save`
+- install node-osc `npm install node-osc --save` (do we need this ?)
+- install osc-js `npm install node-osc --save`
+
+install serial package : `pip3 install pyserial`
 
 # wjhat follows is info, not instructions for setup:
 

dotfiles/python_for_shutting_down_osc_server.py

@@ -3,15 +3,17 @@ from pythonosc import udp_client
 from pythonosc import dispatcher
 import argparse
 
-def setup_osc_client():
+def setup_osc_client(ip, port):
     client_parser = argparse.ArgumentParser()
-    client_parser.add_argument("--ip", default="127.0.0.1", help="the ip")
+    client_parser.add_argument("--ip", default=ip, help="the ip")
-    client_parser.add_argument("--port", type=int, default=5433, help="the port")
+    client_parser.add_argument("--port", type=int, default=port, help="the port")
 
     client_args = client_parser.parse_args()
 
     return udp_client.SimpleUDPClient(client_args.ip, client_args.port)
 
-client = setup_osc_client()
+client = setup_osc_client('127.0.0.1',5433)
-
+client.send_message("/shutdown", True)
+
+client = setup_osc_client('127.0.0.1',9000)
 client.send_message("/shutdown", True)

json_objects/keypad_action_mapping.json

@@ -1,9 +1,9 @@
 {
 	"a": {
-		"NAV_BROWSER": ["move_browser_selection_up"],
+		"NAV_BROWSER": ["move_browser_selection_up", "move_browser_selection_page_up"],
 		"DEFAULT": ["seek_back_on_player", "decrease_seek_time"],
-		"NAV_SETTINGS": ["move_settings_selection_up"],
+		"NAV_SETTINGS": ["move_settings_selection_up", "move_settings_selection_page_up"],
-		"NAV_SHADERS": ["move_shaders_selection_up"],
+		"NAV_SHADERS": ["move_shaders_selection_up", "move_shaders_selection_page_up"],
         "LENGTH_SET": ["return_to_default_control_mode"],
         "CONFIRM": ["return_to_default_control_mode"],
         "SHADER_PARAM": ["decrease_this_param", "decrease_shader_param"],
@@ -11,10 +11,10 @@
 	"NAV_WJMX": ["wj_select_previous_command"]
 	},
 	"b": {
-		"NAV_BROWSER": ["move_browser_selection_down"],
+		"NAV_BROWSER": ["move_browser_selection_down", "move_browser_selection_page_down"],
 		"DEFAULT": ["seek_forward_on_player", "increase_seek_time"],
-		"NAV_SETTINGS": ["move_settings_selection_down"],
+		"NAV_SETTINGS": ["move_settings_selection_down", "move_settings_selection_page_down"],
-		"NAV_SHADERS": ["move_shaders_selection_down"],
+		"NAV_SHADERS": ["move_shaders_selection_down", "move_shaders_selection_page_down"],
         "LENGTH_SET": ["return_to_default_control_mode"],
         "CONFIRM": ["return_to_default_control_mode"],
         "SHADER_PARAM": ["increase_this_param", "increase_shader_param"],
@@ -105,5 +105,13 @@
 	"s": {
 		"DEFAULT": ["load_slot_9_into_next_player","confirm_shutdown"],
         "PLAY_SHADER": ["play_shader_9","confirm_shutdown"]
+    },
+    "x_m": {
+		"DEFAULT": ["set_the_shader_param_0_layer_offset_0_continuous"],
+        "NAV_DETOUR": ["set_detour_mix_continuous"]
+	},
+    "y_m": {
+		"DEFAULT": ["set_the_shader_param_1_layer_offset_0_continuous"],
+        "NAV_DETOUR": ["set_detour_speed_position_continuous"]
 	}
 }

json_objects/midi_action_mapping.json

@@ -43,25 +43,24 @@
 		"DEFAULT": ["set_strobe_amount_continuous"]
 	},
 	"note_on 72": {
-		"NAV_BROWSER": ["move_browser_selection_up"],
+		"NAV_BROWSER": ["move_browser_selection_up", "move_browser_selection_page_up"],
 		"DEFAULT": ["seek_back_on_player", "decrease_seek_time"],
-		"NAV_SETTINGS": ["move_settings_selection_up"],
+		"NAV_SETTINGS": ["move_settings_selection_up", "move_settings_selection_page_up"],
-		"NAV_SHADERS": ["move_shaders_selection_up"],
+		"NAV_SHADERS": ["move_shaders_selection_up", "move_shaders_selection_page_up"],
         "LENGTH_SET": ["return_to_default_control_mode"],
         "CONFIRM": ["return_to_default_control_mode"],
         "SHADER_PARAM": ["decrease_this_param", "decrease_shader_param"],
         "PLAY_SHADER": ["decrease_this_param", "decrease_shader_param"]
 	},
 	"note_on 73": {
-		"NAV_BROWSER": ["move_browser_selection_down"],
+		"NAV_BROWSER": ["move_browser_selection_down", "move_browser_selection_page_down"],
 		"DEFAULT": ["seek_forward_on_player", "increase_seek_time"],
-		"NAV_SETTINGS": ["move_settings_selection_down"],
+		"NAV_SETTINGS": ["move_settings_selection_down", "move_settings_selection_page_down"],
-		"NAV_SHADERS": ["move_shaders_selection_down"],
+		"NAV_SHADERS": ["move_shaders_selection_down", "move_shaders_selection_page_down"],
         "LENGTH_SET": ["return_to_default_control_mode"],
         "CONFIRM": ["return_to_default_control_mode"],
         "SHADER_PARAM": ["increase_this_param", "increase_shader_param"],
         "PLAY_SHADER": ["increase_this_param", "increase_shader_param"]
-
     },
 	"note_on 74": {
 		"NAV_BROWSER": ["enter_on_browser_selection"],

json_objects/osc_action_mapping.json

@@ -16,25 +16,25 @@
         "NAV_DETOUR": ["set_detour_end_continuous"]
 	},
 	"a": {
-		"NAV_BROWSER": ["move_browser_selection_up"],
+		"NAV_BROWSER": ["move_browser_selection_down", "move_browser_selection_page_down"],
-		"DEFAULT": ["seek_back_on_player", "decrease_seek_time"],
-		"NAV_SETTINGS": ["move_settings_selection_up"],
-		"NAV_SHADERS": ["move_shaders_selection_up"],
-        "LENGTH_SET": ["return_to_default_control_mode"],
-        "CONFIRM": ["return_to_default_control_mode"],
-        "SHADER_PARAM": ["decrease_this_param", "decrease_shader_param"],
-        "PLAY_SHADER": ["decrease_this_param", "decrease_shader_param"]
-	},
-	"b": {
-		"NAV_BROWSER": ["move_browser_selection_down"],
 		"DEFAULT": ["seek_forward_on_player", "increase_seek_time"],
-		"NAV_SETTINGS": ["move_settings_selection_down"],
+		"NAV_SETTINGS": ["move_settings_selection_down", "move_settings_selection_page_down"],
-		"NAV_SHADERS": ["move_shaders_selection_down"],
+		"NAV_SHADERS": ["move_shaders_selection_down", "move_shaders_selection_page_down"],
         "LENGTH_SET": ["return_to_default_control_mode"],
         "CONFIRM": ["return_to_default_control_mode"],
         "SHADER_PARAM": ["increase_this_param", "increase_shader_param"],
         "PLAY_SHADER": ["increase_this_param", "increase_shader_param"]
-
+    },
+	"b": {
+		"NAV_BROWSER": ["enter_on_browser_selection"],
+		"DEFAULT": ["toggle_action_on_player","toggle_show_on_player"],
+		"NAV_SETTINGS": ["enter_on_settings_selection"],
+		"NAV_SHADERS": ["enter_on_shaders_selection", "map_on_shaders_selection"],
+        "LENGTH_SET": ["record_fixed_length"],
+        "SHADER_PARAM": ["return_to_default_control_mode"],
+        "CONFIRM": ["perform_confirm_action"],
+        "NAV_DETOUR": ["toggle_detour_play"],
+        "PLAY_SHADER": ["toggle_shaders", "toggle_shader_speed"]
 	},
 	"c": {
 		"NAV_BROWSER": ["enter_on_browser_selection"],

json_objects/settings_default.json

@@ -112,6 +112,43 @@
             "options": [],
             "value": null
         },
+        "OSC_INPUT": {
+            "action": null,
+            "options": [
+                "enabled",
+                "disabled"
+            ],
+            "value": "disabled"
+        },
+        "ACCESS_POINT": {
+            "action": "toggle_access_point",
+            "options": [
+                "enabled",
+                "disabled"
+            ],
+            "value": "disabled"
+        },
+        "REMOTE_SERVER": {
+            "action": "toggle_remote_server",
+            "options": [
+                "enabled",
+                "disabled"
+            ],
+            "value": "disabled"
+        },
+        "SHOW_IP": {
+            "action": "show_ip",
+            "options": [],
+            "value": null
+        },
+        "MOUSE_INPUT": {
+            "action": null,
+            "options": [
+                "enabled",
+                "disabled"
+            ],
+            "value": "disabled"
+        },
         "ANALOG_INPUT": {
             "action": null,
             "options": [
@@ -155,6 +192,11 @@
             "options": [],
             "value": null
         },
+        "EJECT_USB_DRIVES": {
+            "action": "eject_all_usb_drives",
+            "options": [],
+            "value": null
+        },   
         "RESTART_OPENFRAMEWORKS": {
             "action": "restart_openframeworks",
             "options": [],

user_input/midi_input.py

@@ -37,11 +37,13 @@ class MidiInput(object):
 
     def open_this_port_and_start_listening(self, port_phrase):
         midi_ports = mido.get_input_names()
-        midi_device_on_port = [s for s in midi_ports if port_phrase in s]
+        midi_devices = [s for s in midi_ports if not ('Midi Through' in s)]
-        if midi_device_on_port:
+        if port_phrase == 'serial':
+            midi_devices = [s for s in midi_devices if port_phrase in s]
+        if midi_devices:
             if self.data.midi_status == 'disconnected':
-                subport_index = self.port_index % len(midi_device_on_port) 
+                subport_index = self.port_index % len(midi_devices) 
-                self.midi_device = mido.open_input(midi_device_on_port[subport_index])
+                self.midi_device = mido.open_input(midi_devices[subport_index])
                 self.data.midi_status = 'connected'
                 self.data.midi_device_name = self.midi_device.name
                 self.message_handler.set_message('INFO', 'connected to midi device {}'.format(self.midi_device.name))

user_input/numpad_input.py

@@ -16,6 +16,7 @@ class NumpadInput(object):
     def bind_actions(self):
         self.display.display_text.bind("<KeyPress>", self.on_key_press)
         self.display.display_text.bind("<KeyRelease>", self.on_key_release)
+        self.display.display_text.bind("<Motion>", self.on_mouse_move)
 
     def on_key_press(self, event):
         numpad = list(string.ascii_lowercase[0:19])
@@ -34,7 +35,19 @@ class NumpadInput(object):
             if event.char in numpad:
                 self.check_key_release_settings(event.char)
 
-    def run_action_for_mapped_key(self, key):
+    def on_mouse_move(self, event):
+        if self.data.settings['user_input']['MOUSE_INPUT']['value'] != 'enabled':
+            return
+        if event.x > 480 or event.y > 320:
+            return
+        width = 480
+        height = 320 # hard coded since display is fixed , and reading screen is more work
+
+        self.root.after(0, self.run_action_for_mapped_key, 'x_m', event.x / width)
+        self.root.after(0, self.run_action_for_mapped_key, 'y_m', event.y / height)
+        #self.run_action_for_mapped_key(event.char)
+
+    def run_action_for_mapped_key(self, key, value=-1):
         this_mapping = self.key_mappings[key]
         if self.data.control_mode in this_mapping:
             mode = self.data.control_mode
@@ -42,16 +55,20 @@ class NumpadInput(object):
             mode = 'DEFAULT'
 
         if self.data.function_on and len(this_mapping[mode]) > 1:
-            print('the action being called is {}'.format(this_mapping[mode][1]))
+            is_function = 1
-            #getattr(self.actions, this_mapping[mode][1])()
-            self.actions.call_method_name(this_mapping[mode][1])
-            if self.data.settings['sampler']['FUNC_GATED']['value'] == 'off':
-                self.data.function_on = False
         else:
-            print('the action being called is {}'.format(this_mapping[mode][0]))
+            is_function = 0
-            #getattr(self.actions, this_mapping[mode][0])()
-            self.actions.call_method_name(this_mapping[mode][0])
             
+        print('the action being called is {}'.format(this_mapping[mode][is_function]))
+        if value != -1:
+            getattr(self.actions, this_mapping[mode][is_function])(value)
+        else:
+            getattr(self.actions, this_mapping[mode][is_function])()
+
+        if is_function and self.data.settings['sampler']['FUNC_GATED']['value'] == 'off':
+            self.data.function_on = False
+
+        if not value:
             self.display.refresh_display()
 
 

user_input/osc_input.py

@@ -17,12 +17,28 @@ class OscInput(object):
         self.actions = actions
         self.data = data
         self.osc_mappings = data.osc_mappings
-        self.osc_server = self.setup_osc_server()
+        
+        self.osc_enabled = False
+        self.osc_server = None
+        self.poll_settings_for_osc_info()
+
+    def poll_settings_for_osc_info(self):
+        osc_setting_enabled = self.data.settings['user_input']['OSC_INPUT']['value'] == 'enabled'
+        if osc_setting_enabled and not self.osc_enabled:
+            self.setup_osc_server()
+            self.osc_enabled = True
+        elif not osc_setting_enabled and self.osc_enabled:
+            self.actions.create_client_and_shutdown_osc_server()
+            self.osc_enabled = False
+        self.root.after(1000, self.poll_settings_for_osc_info)
 
     def setup_osc_server(self):
+        ip_address = self.data.get_ip_for_osc_client()
+
+        print('%%%%%%%%%%%%%%%%%%%%% setting up external_osc on ', ip_address)
         server_parser = argparse.ArgumentParser()
-        server_parser.add_argument("--ip", default="0.0.0.0", help="the ip")
+        server_parser.add_argument("--ip", default=ip_address, help="the ip")
-        server_parser.add_argument("--port", type=int, default=5433, help="the port")
+        server_parser.add_argument("--port", type=int, default=8080, help="the port")
 
         server_args = server_parser.parse_args()
 
@@ -34,14 +50,16 @@ class OscInput(object):
         this_dispatcher.map("/shaderparam2", 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("/*", self.on_param_osc_input)
+        #this_dispatcher.map("/*", print)        
 
+        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()
-        return server
+        self.osc_server = server
 
     def exit_osc_server(self, unused_addr, args):
+        print('%%%%%%%%%%%%%%%%%%%%% exiting external_osc')
         self.osc_server.shutdown()
 
     def on_osc_input(self, addr, args):

video_centre/shaders.py

@@ -263,7 +263,7 @@ class Shaders(object):
 
     def set_speed_to_amount(self, amount, layer_offset=0):
         layer = (self.data.shader_layer + layer_offset) % 3
-        self.set_speed_to_amount_layer(layer)
+        self.set_speed_layer_to_amount(layer, amount)
    
     def set_speed_layer_to_amount(self, layer, amount):
         self.osc_client.send_message("/shader/{}/speed".format(str(layer)), amount )