Serve as base OSC server for the Tascam Console Unittascam_fw_console-0.2

We remove the Ardour specific OSC mapping and create our own OSC
API that will be consumed by OSC translators that communicate to
specific applications.

We only send the state of each control and set the state of each
fader or led based on received commands.

Logic for interpreting the control state will be moved to the OSC
translator code.

8 files changed, 200 insertions, 407 deletions

diff --git a/tascam_fw_console/buttons.py b/tascam_fw_console/buttons.py
index 35448c3..df9bf0f 100644
--- a/tascam_fw_console/buttons.py
+++ b/tascam_fw_console/buttons.py
@@ -21,7 +21,6 @@
 """
 
 import re
-import pyautogui
 from tascam_fw_console import osc
 
 
@@ -42,209 +41,53 @@ re_strip_num = re.compile('.*([1-9])')
 
 
 class Button():
-    def __init__(self, console, name):
+    def __init__(self, console, name, addr):
         self.name = name
-        self.state = 0
+        self.pressed = False
+        self.enabled = False
         self.console = console
+        self.press_callbacks = set()
+        self.release_callbacks = set()
+        self.addr = '/button/{}'.format(addr)
+        osc.dispatcher.map(self.addr, self.osc_handle)
 
     def press(self):
-        self.state = 1
-        print('%s pressed' % self.name)
+        self.pressed = True
+        osc.client.send_message(self.addr, 1)
 
     def release(self):
-        self.state = 0
-        print('%s released' % self.name)
-
-    @property
-    def pressed(self):
-        if self.state:
-            return True
-        return False
-
-
-class EncoderButton(Button):
-    def __init__(self, console, name):
-        super().__init__(console, name)
-
-    def press(self):
-
-        encoder_mode = self.console.state.get('encoder_mode', None)
-        print(encoder_mode)
-        if encoder_mode == self.name:
-            return
-
-        self.state = 1
-        if encoder_mode:
-            self.console.unit.leds.turn_off(encoder_mode)
-            self.console.state[encoder_mode] = 0
-        self.console.unit.leds.turn_on(self.name)
-        self.console.state['encoder_mode'] = self.name
-        super().press()
-
-
-class StripSelButton(Button):
-    def __init__(self, console, name, strip):
-        super().__init__(console, name)
-        self.strip = strip
-        self.strip.select_button = self
-
-    def press(self):
-
-        strip = self.strip
-        print('handle_strip_sel', strip)
-        recenable = self.console.buttons.get('REC ENABLE', None)
-        if recenable.pressed:
-            if strip.rec:
-                osc.client.send_message('/strip/recenable', (strip.num, 0))
-            else:
-                osc.client.send_message('/strip/recenable', (strip.num, 1))
-        super().press()
-
-
-class StripMuteButton(Button):
-    def __init__(self, console, name, strip):
-        super().__init__(console, name)
-        self.strip = strip
-        self.strip.mute_button = self
-
-    def press(self):
-
-        strip = self.strip
-        if strip.mute:
-            strip.mute = False
-            osc.client.send_message('/strip/mute', (strip.num, 0))
+        self.pressed = False
+        osc.client.send_message(self.addr, 0)
+
+    def osc_handle(self, addr, enable):
+        print(self.name)
+        if enable:
+            self.enabled = True
+            self.console.unit.leds.turn_on(self.name)
         else:
-            strip.mute = True
-            osc.client.send_message('/strip/mute', (strip.num, 1))
-        super().press()
-
-
-class StripSoloButton(Button):
-    def __init__(self, console, name, strip):
-        super().__init__(console, name)
-        self.strip = strip
-        self.strip.solo_button = self
+            self.enabled = False
+            self.console.unit.leds.turn_off(self.name)
+
+
+class StripButton(Button):
+    def __init__(self, console, name, addr, strip):
+        super().__init__(console, name, addr)
+        self.strip = console.strips[strip]
+        button = addr.split('/')[-1]
+        if button == 'sel':
+            self.strip.select_button = self
+            self.osc_handler = console.strip_select_handler
+        elif button == 'mute':
+            self.strip.mute_button = self
+            self.osc_handler = console.strip_mute_handler
+        elif button == 'solo':
+            self.strip.solo_button = self
+            self.osc_handler = console.strip_solo_handler
 
     def press(self):
-
-        strip = self.strip
-        if strip.solo:
-            strip.solo = False
-            osc.client.send_message('/strip/solo', (strip.num, 0))
-        else:
-            strip.solo = True
-            osc.client.send_message('/strip/solo', (strip.num, 1))
-        super().press()
-
-
-class ArrowButton(Button):
-    def __init__(self, console, name):
-        super().__init__(console, name)
-
-    def press(self):
-        key = keymap.get(self.name.lower(), self.name.lower())
-        pyautogui.press(key)
-
-
-class ModButton(Button):
-    def __init__(self, console, name):
-        super().__init__(console, name)
-
-    def mod_button_press(self):
-        key = keymap.get(self.name, None)
-        if key is None:
-            return
-
-        pyautogui.keyDown(key)
-        super().press()
+        self.pressed = True
+        osc.client.send_message(self.addr, (self.strip.num, 1))
 
     def release(self):
-        key = keymap.get(self.name, None)
-        if key is None:
-            return
-
-        pyautogui.keyUp(key)
-        super().release()
-
-
-class ComputerButton(Button):
-    def __init__(self, console, name):
-        super().__init__(console, name)
-
-    def press(self):
-        osc.client.send_message('/set_surface', (8, 7, 19, 1, 8, 11))
-        super().press()
-
-
-class ClrSoloButton(Button):
-    def __init__(self, console, name):
-        super().__init__(console, name)
-
-    def press(self):
-        osc.client.send_message('/cancel_all_solos', 1)
-        super().press()
-
-
-class LoopButton(Button):
-    def __init__(self, console, name):
-        super().__init__(console, name)
-
-    def press(self, *args):
-        if self.console.state.get('loop', 0):
-            print('******* loop off')
-            osc.client.send_message('/loop_toggle', 0)
-        else:
-            print('******* loop on')
-            osc.client.send_message('/loop_toggle', 1)
-        super().press()
-
-
-class TransportButton(Button):
-    def __init__(self, console, name):
-        super().__init__(console, name)
-
-    def press(self):
-        addr = osc_addrs.get(self.name, None)
-        if addr:
-            osc.client.send_message(addr, 1)
-        super().press()
-
-
-class BankSwitchButton(Button):
-    def __init__(self, console, name, direction):
-        super().__init__(console, name)
-        self.direction = direction
-
-    def press(self):
-
-        direction = self.direction
-        more_up = self.console.more_banks_up
-        more_down = self.console.more_banks_down
-        print(direction, more_up, more_down)
-        if direction > 0 and more_up:
-            print('calling /bank_up 1')
-            osc.client.send_message('/bank_up', 1)
-        elif direction < 0 and more_down:
-            print('calling /bank_down 1')
-            osc.client.send_message('/bank_down', 1)
-        super().press()
-
-
-class NudgeButton(Button):
-    def __init__(self, console, name, direction):
-        super().__init__(console, name)
-        self.direction = direction
-
-    def nudge_press(self):
-        direction = self.direction
-        print(direction)
-        if direction > 0:
-            osc.client.send_message('/access_action',
-                                    'Common/nudge-next-forward')
-        else:
-            osc.client.send_message('/access_action',
-                                    'Common/nudge-next-backward')
-        super().press()
-
-
-NULLBUTTON = Button(None, None)
+        self.pressed = False
+        osc.client.send_message(self.addr, (self.strip.num, 0))
diff --git a/tascam_fw_console/cli.py b/tascam_fw_console/cli.py
index 7db084b..2319ad9 100644
--- a/tascam_fw_console/cli.py
+++ b/tascam_fw_console/cli.py
@@ -28,9 +28,9 @@ Options:
     -c CARD_NUM --card=CARD_NUM  Number of the ALSA sound card
     -d GUID --device=GUID        GUID of the FW unit
     -I IP --listen-ip=IP         IP to listen on [default: 127.0.0.1]
-    -P PORT --listen-port=PORT   Port to listen on [default: 8000]
+    -P PORT --listen-port=PORT   Port to listen on [default: 8100]
     -i IP --ip=IP                IP to communicate to [default: 127.0.0.1]
-    -p PORT --port=PORT          Port to communicate to [default: 3819]
+    -p PORT --port=PORT          Port to communicate to [default: 9100]
 """
 
 from docopt import docopt
diff --git a/tascam_fw_console/console.py b/tascam_fw_console/console.py
index ccf64af..3f4841a 100644
--- a/tascam_fw_console/console.py
+++ b/tascam_fw_console/console.py
@@ -27,7 +27,6 @@ from pathlib import Path
 
 from tascam_fw_console.encoder import Encoder
 from tascam_fw_console.strip import Strip
-from tascam_fw_console import osc
 from tascam_fw_console import fw_1884_buttons
 
 import gi
@@ -117,33 +116,35 @@ class Console():
         self.current_bank = 1
         self.more_banks_up = True
         self.more_banks_down = True
-        self.strips = self.init_strips()
+        self.init_strips()
         self.buttons = {}
         self.init_buttons()
         self.init_encoder_mode()
         self.init_encoders()
         self.encoders = {
-            10: (self.strips[1].handle_encoder, self.strips[2].handle_encoder),
-            11: (self.strips[3].handle_encoder, self.strips[4].handle_encoder),
-            12: (self.strips[5].handle_encoder, self.strips[6].handle_encoder),
-            13: (self.strips[7].handle_encoder, self.strips[8].handle_encoder),
-            14: (self.handle_gain, self.handle_freq),
-            15: (self.handle_q, self.handle_jog),
+            10: (self.strips[1].encoder.update, self.strips[2].encoder.update),
+            11: (self.strips[3].encoder.update, self.strips[4].encoder.update),
+            12: (self.strips[5].encoder.update, self.strips[6].encoder.update),
+            13: (self.strips[7].encoder.update, self.strips[8].encoder.update),
+            14: (self.gain_encoder.update, self.freq_encoder.update),
+            15: (self.q_encoder.update, self.jogwheel.update),
             }
 
+        self.unit.set_master_fader(False)
         self.unit.connect('control', self.handle_control)
 
         self.status_thread = RunningStatusThread(self)  # noqa F841
 
     def init_strips(self):
+        self.strips = []
         for strip_num in range(0, 9):
             self.strips.append(Strip(self, strip_num))
 
     def init_encoders(self):
-        self.gain_encoder = Encoder()
-        self.freq_encoder = Encoder()
-        self.q_encoder = Encoder()
-        self.jogwheel = Encoder()
+        self.gain_encoder = Encoder('EQ Gain', '/eq/gain')
+        self.freq_encoder = Encoder('EQ Freq', '/eq/freq')
+        self.q_encoder = Encoder('EQ Q', '/eq/q')
+        self.jogwheel = Encoder('Jog', '/jogwheel')
 
     def init_encoder_mode(self):
         self.state['encoder_mode'] = 'PAN'
@@ -197,33 +198,6 @@ class Console():
             else:
                 button.press()
 
-    def handle_gain(self, mode, delta):
-        print('Handle Gain:', mode, delta)
-
-    def handle_freq(self, mode, delta):
-        print('Handle Freq:', mode, delta)
-
-    def handle_q(self, mode, delta):
-        print('Handle Q:', mode, delta)
-
-    def handle_jog(self, mode, delta):
-        print('Handle Jog:', mode, delta)
-        delta = delta * 0.5
-        if self.buttons['ALT'].pressed:
-            if delta > 0:
-                osc.client.send_message('/access_action',
-                                        'Editor/temporal-zoom-in')
-            else:
-                osc.client.send_message('/access_action',
-                                        'Editor/temporal-zoom-out')
-            return
-
-        if self.buttons['SHIFT'].pressed:
-            delta = delta * 0.3
-        if self.buttons['CTRL'].pressed:
-            delta = delta * 0.1
-        osc.client.send_message('/jog', delta)
-
     def handle_encoder(self, index, before, after):
         handler1, handler2 = self.encoders.get(int(index), (None, None))
         bval1 = before & 0xffff
@@ -234,16 +208,15 @@ class Console():
         delta1 = roll_over_delta(aval1 - bval1)
         delta2 = roll_over_delta(aval2 - bval2)
 
-        encoder_mode = self.state.get('encoder_mode', '')
         if delta1 and handler1:
-            handler1(encoder_mode, delta1)
+            handler1(delta1)
 
         if delta2 and handler2:
-            handler2(encoder_mode, delta2)
+            handler2(delta2)
 
     def handle_control(self, unit, index, before, after):
 
-        print('{0:02d}: {1:08x} {2:08x}'.format(index, before, after))
+        # print('{0:02d}: {1:08x} {2:08x}'.format(index, before, after))
 
         if index in [5, 6, 7, 8, 9]:
             self.handle_bit_flags(index, before, after)
@@ -254,15 +227,12 @@ class Console():
             return
 
     def strip_fader_handler(self, addr, ssid, pos):
-        print('fader_handler', addr, ssid, pos)
         strip = self.strips[int(ssid)]
         if strip.name == ' ':
             return
-        pos = pos * 1023
         strip.fader.position = pos
 
     def master_fader_handler(self, addr, pos):
-        print('master_fader_handler', pos)
         self.strip_fader_handler(addr, 0, pos)
 
     def default_handler(self, addr, *args):
@@ -368,8 +338,6 @@ class Console():
 
 
 def roll_over_delta(delta, ceiling=0xffff):
-
-    print(delta)
     if delta > ceiling - 10:
         return delta - (ceiling + 1)
     if delta < -ceiling + 10:
diff --git a/tascam_fw_console/encoder.py b/tascam_fw_console/encoder.py
index 211fef1..ae82234 100644
--- a/tascam_fw_console/encoder.py
+++ b/tascam_fw_console/encoder.py
@@ -20,22 +20,17 @@
     :license: GPL-2.0, see COPYING for details
 """
 
+from tascam_fw_console import osc
+
 
 class Encoder():
-    def __init__(self):
-        self.name = 'Unknown'
-        self.update_callbacks = set()
+    def __init__(self, name, addr, strip=None):
+        self.name = name
+        self.addr = addr
+        self.strip = strip
 
     def update(self, delta):
-        print('Encoder: ', self.name, delta)
-        for callback in self.update_callbacks:
-            try:
-                callback(delta)
-            except Exception('Encoder update callback failed') as e:
-                raise(e)
-
-    def add_callback(self, callback):
-        self.update_callbacks.add(callback)
-
-    def remove_callback(self, callback):
-        self.update_callbacks.remove(callback)
+        if self.strip:
+            osc.client.send_message(self.addr, (self.strip, delta))
+        else:
+            osc.client.send_message(self.addr, delta)
diff --git a/tascam_fw_console/fader.py b/tascam_fw_console/fader.py
index ab20eaa..0169322 100644
--- a/tascam_fw_console/fader.py
+++ b/tascam_fw_console/fader.py
@@ -20,7 +20,6 @@
     :license: GPL-2.0, see COPYING for details
 """
 
-from tascam_fw_console.buttons import Button
 from tascam_fw_console import osc
 
 status_quadlets = (4, 0, 0, 1, 1, 2, 2, 3, 3)
@@ -36,38 +35,46 @@ status_bits = ((1, 16),
                )
 
 
-class Fader(Button):
+class Fader():
     def __init__(self, strip):
-        name = 'Strip {} Fader'. format(strip.num)
-        super().__init__(strip.console, name)
+        self.name = 'Strip {} Fader'. format(strip.num)
         self.strip = strip
+        self.console = strip.console
         if self.strip.num == 0:
             self.addr = '/master/fader'
+            self.press_args = (self.strip.num, 1)
+            self.release_args = (self.strip.num, 0)
         else:
             self.addr = '/strip/fader'
+            self.press_args = (1,)
+            self.release_args = (0,)
         self.status_quadlet = status_quadlets[self.strip.num]
         self.status_bits = status_bits[self.strip.num]
         self.status_callback = self.send_pos
 
     @property
     def position(self):
-        return self.console.status.field(self.status_quadlet, *self.status_bits)
+        return self.console.status.field(self.status_quadlet,
+                                         *self.status_bits)
 
     @position.setter
     def position(self, pos):
         self.console.unit.strips[self.strip.num].fader.set_position(pos)
 
     def send_pos(self, pos):
-        print('{}, ({}, {})'.format(self.addr, self.strip.num, pos/1023))
         if self.strip.num == 0:
-            osc.client.send_message(self.addr, pos/1023)
+            osc.client.send_message(self.addr, pos)
         else:
-            osc.client.send_message(self.addr, (self.strip.num, pos/1023))
+            osc.client.send_message(self.addr, (self.strip.num, pos))
 
     def press(self):
+        addr = '{}_touch'.format(self.addr)
+        args = self.press_args + (1,)
+        osc.client.send_message(addr, args)
         self.console.status_thread.add_callback(self)
-        super().press()
 
     def release(self):
+        addr = '{}_touch'.format(self.addr)
+        args = self.press_args + (0,)
+        osc.client.send_message(addr, args)
         self.console.status_thread.remove_callback(self)
-        super().press()
diff --git a/tascam_fw_console/fw_1884_buttons.py b/tascam_fw_console/fw_1884_buttons.py
index 44f3b60..6eea65d 100644
--- a/tascam_fw_console/fw_1884_buttons.py
+++ b/tascam_fw_console/fw_1884_buttons.py
@@ -74,74 +74,69 @@ def init_buttons(console):
                 None,
                 None,
                 None,
-                buttons.StripSelButton(console, 'Strip 1 Sel', strips[1]),
-                buttons.StripSelButton(console, 'Strip 2 Sel', strips[2]),
-                buttons.StripSelButton(console, 'Strip 3 Sel', strips[3]),
-                buttons.StripSelButton(console, 'Strip 4 Sel', strips[4]),
-                buttons.StripSelButton(console, 'Strip 5 Sel', strips[5]),
-                buttons.StripSelButton(console, 'Strip 6 Sel', strips[6]),
-                buttons.StripSelButton(console, 'Strip 7 Sel', strips[7]),
-                buttons.StripSelButton(console, 'Strip 8 Sel', strips[8]),
-                buttons.StripSoloButton(console, 'Strip 1 Solo', strips[1]),
-                buttons.StripSoloButton(console, 'Strip 2 Solo', strips[2]),
-                buttons.StripSoloButton(console, 'Strip 3 Solo', strips[3]),
-                buttons.StripSoloButton(console, 'Strip 4 Solo', strips[4]),
-                buttons.StripSoloButton(console, 'Strip 5 Solo', strips[5]),
-                buttons.StripSoloButton(console, 'Strip 6 Solo', strips[6]),
-                buttons.StripSoloButton(console, 'Strip 7 Solo', strips[7]),
-                buttons.StripSoloButton(console, 'Strip 8 Solo', strips[8]),
+                buttons.StripButton(console, 'Strip 1 Sel', 'strip/sel', 1),
+                buttons.StripButton(console, 'Strip 2 Sel', 'strip/sel', 2),
+                buttons.StripButton(console, 'Strip 3 Sel', 'strip/sel', 3),
+                buttons.StripButton(console, 'Strip 4 Sel', 'strip/sel', 4),
+                buttons.StripButton(console, 'Strip 5 Sel', 'strip/sel', 5),
+                buttons.StripButton(console, 'Strip 6 Sel', 'strip/sel', 6),
+                buttons.StripButton(console, 'Strip 7 Sel', 'strip/sel', 7),
+                buttons.StripButton(console, 'Strip 8 Sel', 'strip/sel', 8),
+                buttons.StripButton(console, 'Strip 1 Solo', 'strip/solo', 1),
+                buttons.StripButton(console, 'Strip 2 Solo', 'strip/solo', 2),
+                buttons.StripButton(console, 'Strip 3 Solo', 'strip/solo', 3),
+                buttons.StripButton(console, 'Strip 4 Solo', 'strip/solo', 4),
+                buttons.StripButton(console, 'Strip 5 Solo', 'strip/solo', 5),
+                buttons.StripButton(console, 'Strip 6 Solo', 'strip/solo', 6),
+                buttons.StripButton(console, 'Strip 7 Solo', 'strip/solo', 7),
+                buttons.StripButton(console, 'Strip 8 Solo', 'strip/solo', 8),
                 ],
-            7: [buttons.StripMuteButton(console, 'Strip 1 Mute', strips[1]),
-                buttons.StripMuteButton(console, 'Strip 2 Mute', strips[2]),
-                buttons.StripMuteButton(console, 'Strip 3 Mute', strips[3]),
-                buttons.StripMuteButton(console, 'Strip 4 Mute', strips[4]),
-                buttons.StripMuteButton(console, 'Strip 5 Mute', strips[5]),
-                buttons.StripMuteButton(console, 'Strip 6 Mute', strips[6]),
-                buttons.StripMuteButton(console, 'Strip 7 Mute', strips[7]),
-                buttons.StripMuteButton(console, 'Strip 8 Mute', strips[8]),
-                buttons.EncoderButton(console, 'AUX5'),
-                buttons.EncoderButton(console, 'AUX7'),
-                buttons.EncoderButton(console, 'AUX6'),
-                buttons.EncoderButton(console, 'AUX8'),
-                None,
-                None,
-                None,
-                None,
-                buttons.Button(console, 'FLIP'),
-                buttons.EncoderButton(console, 'AUX1'),
-                buttons.EncoderButton(console, 'AUX3'),
-                buttons.EncoderButton(console, 'PAN'),
-                buttons.EncoderButton(console, 'AUX2'),
-                buttons.EncoderButton(console, 'AUX4'),
-                None,
-                None,
-                buttons.Button(console, 'Control Panel'),
-                buttons.Button(console, 'F1'),
-                buttons.Button(console, 'ALL SAFE'),
-                buttons.Button(console, 'F5'),
-                buttons.Button(console, 'CUT'),
-                buttons.Button(console, 'COPY'),
-                buttons.ModButton(console, 'ALT'),
-                buttons.ModButton(console, 'SHIFT'),
+            7: [buttons.StripButton(console, 'Strip 1 Mute', 'strip/mute', 1),
+                buttons.StripButton(console, 'Strip 2 Mute', 'strip/mute', 2),
+                buttons.StripButton(console, 'Strip 3 Mute', 'strip/mute', 3),
+                buttons.StripButton(console, 'Strip 4 Mute', 'strip/mute', 4),
+                buttons.StripButton(console, 'Strip 5 Mute', 'strip/mute', 5),
+                buttons.StripButton(console, 'Strip 6 Mute', 'strip/mute', 6),
+                buttons.StripButton(console, 'Strip 7 Mute', 'strip/mute', 7),
+                buttons.StripButton(console, 'Strip 8 Mute', 'strip/mute', 8),
+                buttons.Button(console, 'AUX5', 'encoders/aux5'),
+                buttons.Button(console, 'AUX7', 'encoders/aux7'),
+                buttons.Button(console, 'AUX6', 'encoders/aux6'),
+                buttons.Button(console, 'AUX8', 'encoders/aux8'),
+                None,
+                None,
+                None,
+                None,
+                buttons.Button(console, 'FLIP', 'encoders/flip'),
+                buttons.Button(console, 'AUX1', 'encoders/aux1'),
+                buttons.Button(console, 'AUX3', 'encoders/aux3'),
+                buttons.Button(console, 'PAN', 'encoders/pan'),
+                buttons.Button(console, 'AUX2', 'encoders/aux2'),
+                buttons.Button(console, 'AUX4', 'encoders/aux4'),
+                None,
+                None,
+                buttons.Button(console, 'Control Panel',
+                               'shortcuts/control_panel'),
+                buttons.Button(console, 'SAVE', 'shortcuts/save'),
+                buttons.Button(console, 'ALL SAFE', 'shortcuts/all_safe'),
+                buttons.Button(console, 'MARKER', 'shortcuts/marker'),
+                buttons.Button(console, 'CUT', 'shortcuts/cut'),
+                buttons.Button(console, 'COPY', 'shortcuts/copy'),
+                buttons.Button(console, 'ALT', 'shortcuts/alt'),
+                buttons.Button(console, 'SHIFT', 'shortcuts/shift'),
                 ],
-            8: [buttons.Button(console, 'F2'),
-                buttons.ClrSoloButton(console, 'CLR SOLO'),
-                buttons.LoopButton(console, 'LOOP'),
-                buttons.Button(console, 'DEL'),
-                buttons.Button(console, 'PASTE'),
-                buttons.Button(console, 'UNDO'),
-                buttons.ModButton(console, 'CTRL'),
-                buttons.Button(console, 'Foot Switch'),
-                buttons.Button(console, 'Gain Enc A'),
-                buttons.Button(console, 'Gain Enc B'),
-                buttons.Button(console, 'Q Enc A'),
-                buttons.Button(console, 'Q Enc B'),
+            8: [buttons.Button(console, 'REVERT', 'shortcuts/revert'),
+                buttons.Button(console, 'CLR SOLO', 'shortcuts/clr_solo'),
+                buttons.Button(console, 'LOOP', 'shortcuts/loop'),
+                buttons.Button(console, 'DEL', 'shortcuts/del'),
+                buttons.Button(console, 'PASTE', 'shortcuts/paste'),
+                buttons.Button(console, 'UNDO', 'shortcuts/undo'),
+                buttons.Button(console, 'CTRL', 'shortcuts/ctrl'),
+                buttons.Button(console, 'Foot Switch', 'foot_switch'),
                 None,
                 None,
                 None,
                 None,
-                buttons.Button(console, 'Freq Enc A'),
-                buttons.Button(console, 'Freq Enc B'),
                 None,
                 None,
                 None,
@@ -149,45 +144,51 @@ def init_buttons(console):
                 None,
                 None,
                 None,
-                buttons.ComputerButton(console, 'COMPUTER'),
                 None,
                 None,
-                buttons.Button(console, 'CLOCK'),
-                buttons.Button(console, 'ROUTE'),
+                None,
+                None,
+                None,
+                None,
+                buttons.Button(console, 'COMPUTER', 'computer'),
+                None,
+                None,
+                buttons.Button(console, 'CLOCK', 'clock'),
+                buttons.Button(console, 'ROUTE', 'route'),
                 None,
                 None,
                 ],
-            9: [buttons.Button(console, 'F7'),
-                buttons.Button(console, 'F8'),
-                buttons.Button(console, 'F9'),
-                buttons.Button(console, 'F10'),
-                buttons.Button(console, 'READ'),
-                buttons.Button(console, 'WRT'),
-                buttons.Button(console, 'TCH'),
-                buttons.Button(console, 'LATCH'),
-                buttons.Button(console, 'HIGH'),
-                buttons.Button(console, 'HI-MID'),
-                buttons.Button(console, 'LOW-MID'),
-                buttons.Button(console, 'LOW'),
-                buttons.ArrowButton(console, 'UP'),
-                buttons.ArrowButton(console, 'LEFT'),
-                buttons.ArrowButton(console, 'DOWN'),
-                buttons.ArrowButton(console, 'RIGHT'),
-                buttons.Button(console, 'REC ENABLE'),
-                buttons.NudgeButton(console, 'NUDGE LEFT', -1),
-                buttons.NudgeButton(console, 'NUDGE RIGHT', 1),
-                buttons.BankSwitchButton(console, 'BANK LEFT', -1),
-                buttons.BankSwitchButton(console, 'BANK RIGHT', 1),
-                buttons.Button(console, 'LOCATE LEFT'),
-                buttons.Button(console, 'LOCATE RIGHT'),
-                buttons.Button(console, 'SHTL'),
-                buttons.Button(console, 'SET'),
-                buttons.Button(console, 'IN'),
-                buttons.Button(console, 'OUT'),
-                buttons.TransportButton(console, 'REW'),
-                buttons.TransportButton(console, 'F.FWD'),
-                buttons.TransportButton(console, 'STOP'),
-                buttons.TransportButton(console, 'PLAY'),
-                buttons.TransportButton(console, 'REC'),
+            9: [buttons.Button(console, 'F7', 'f7'),
+                buttons.Button(console, 'F8', 'f8'),
+                buttons.Button(console, 'F9', 'f9'),
+                buttons.Button(console, 'F10', 'f10'),
+                buttons.Button(console, 'READ', 'read'),
+                buttons.Button(console, 'WRT', 'write'),
+                buttons.Button(console, 'TCH', 'touch'),
+                buttons.Button(console, 'LATCH', 'latch'),
+                buttons.Button(console, 'HIGH', 'eq/high'),
+                buttons.Button(console, 'HI-MID', 'eq/hi_mid'),
+                buttons.Button(console, 'LOW-MID', 'eq/low_mid'),
+                buttons.Button(console, 'LOW', 'eq/low'),
+                buttons.Button(console, 'UP', 'arrow_up'),
+                buttons.Button(console, 'LEFT', 'arrow_left'),
+                buttons.Button(console, 'DOWN', 'arrow_down'),
+                buttons.Button(console, 'RIGHT', 'arrow_right'),
+                buttons.Button(console, 'REC ENABLE', 'rec_enable'),
+                buttons.Button(console, 'NUDGE LEFT', 'nudge_left'),
+                buttons.Button(console, 'NUDGE RIGHT', 'nudge_right'),
+                buttons.Button(console, 'BANK LEFT', 'bank_left'),
+                buttons.Button(console, 'BANK RIGHT', 'bank_right'),
+                buttons.Button(console, 'LOCATE LEFT', 'locate_left'),
+                buttons.Button(console, 'LOCATE RIGHT', 'locate_right'),
+                buttons.Button(console, 'SHTL', 'shuttle'),
+                buttons.Button(console, 'SET', 'set'),
+                buttons.Button(console, 'IN', 'in'),
+                buttons.Button(console, 'OUT', 'out'),
+                buttons.Button(console, 'REW', 'transport_rew'),
+                buttons.Button(console, 'F.FWD', 'transport_ffwd'),
+                buttons.Button(console, 'STOP', 'transport_stop'),
+                buttons.Button(console, 'PLAY', 'transport_play'),
+                buttons.Button(console, 'REC', 'transport_rec'),
                 ]
             }
diff --git a/tascam_fw_console/osc.py b/tascam_fw_console/osc.py
index 2892168..46f6fc1 100644
--- a/tascam_fw_console/osc.py
+++ b/tascam_fw_console/osc.py
@@ -29,6 +29,19 @@ server = None
 dispatcher = dispatcher.Dispatcher()
 
 
+class OSCClient(udp_client.SimpleUDPClient):
+    def __init__(self, ip, port):
+        super().__init__(ip, port)
+
+    def send_message(self, addr, args):
+        try:
+            print(addr, *args)
+        except Exception:
+            print(addr, args)
+
+        super().send_message(addr, args)
+
+
 def init_dispatcher(console):
     dispatcher.map("/loop_toggle", console.loop_toggle_handler)
     dispatcher.map("/transport_stop", console.transport_stop_handler)
@@ -53,7 +66,7 @@ def init_dispatcher(console):
 
 def init_client(ip, port):
     global client
-    client = udp_client.SimpleUDPClient(ip, port)
+    client = OSCClient(ip, port)
 
 
 def init_server(ip, port, console):
diff --git a/tascam_fw_console/strip.py b/tascam_fw_console/strip.py
index fe7ca75..f472199 100644
--- a/tascam_fw_console/strip.py
+++ b/tascam_fw_console/strip.py
@@ -22,7 +22,6 @@
 
 from tascam_fw_console.fader import Fader
 from tascam_fw_console.encoder import Encoder
-from tascam_fw_console import osc
 
 
 class Strip():
@@ -39,14 +38,13 @@ class Strip():
         self._rec = False
         self.pan = 0.5
         self.trimdb = 0.0
-        self.encoder = Encoder()
+        self.encoder = Encoder('Strip {}'.format(self.num),
+                               '/strip/encoder',
+                               self.num,
+                               )
         self.fader = Fader(self)
         self.name = None
 
-        self.encoder_handlers = {'PAN': self.send_pan,
-                                 'AUX1': self.send_trim,
-                                 }
-
     @property
     def mute_led(self):
         return self.console.unit.strips[self.num].mute_led
@@ -114,35 +112,3 @@ class Strip():
             self.rec_led.turn_on()
         else:
             self.rec_led.turn_off()
-
-    def send_pan(self, delta):
-        addr = '/strip/pan_stereo_position'
-        pan = self.pan + delta * 0.02
-        if pan < 0:
-            pan = 0
-        if pan > 1.0:
-            pan = 1.0
-        osc.client.send_message(addr, (self.num, pan))
-
-    def recv_pan(self, pan):
-        print('Pan: {} {}'.format(self.num, pan))
-        self.pan = pan
-
-    def send_trim(self, delta):
-        addr = '/strip/trimdB'
-        trimdb = self.trimdb + delta * 0.5
-        if trimdb < -20:
-            trimdb = -20
-        if trimdb > 20:
-            trimdb = 20
-        osc.client.send_message(addr, (self.num, trimdb))
-
-    def recv_trim(self, trimdb):
-        print('TrimdB: {} {}'.format(self.num, trimdb))
-        self.trimdb = trimdb
-
-    def handle_encoder(self, mode, delta):
-        self.encoder_handlers.get(mode, self.default_encoder_handler)(delta)
-
-    def default_encoder_handler(self, delta):
-        print(delta)