Add another HID interface using the consumer HID class for media keys. Resolves #32.

2017-03-03 20:21:05 +01:00
parent 1aae668ed5
commit c887b5e309
24 changed files with 604 additions and 344 deletions
--- a/right/src/action.h
+++ b/right/src/action.h
@@ -22,7 +22,8 @@

 typedef enum {
    KEY_ACTION_NONE,
-    KEY_ACTION_KEYSTROKE,
+    KEY_ACTION_BASIC_KEYSTROKE,
+    KEY_ACTION_MEDIA_KEYSTROKE,
    KEY_ACTION_MOUSE,
    KEY_ACTION_SWITCH_LAYER,
    KEY_ACTION_SWITCH_KEYMAP,
--- a/right/src/current_keymap.c
+++ b/right/src/current_keymap.c
@@ -6,95 +6,95 @@ key_action_t CurrentKeymap[LAYER_COUNT][SLOT_COUNT][MAX_KEY_COUNT_PER_MODULE] =
        // Right keyboard half
        {
            // Row 1
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_7_AND_AMPERSAND }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_8_AND_ASTERISK }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_9_AND_OPENING_PARENTHESIS }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_0_AND_CLOSING_PARENTHESIS }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_MINUS_AND_UNDERSCORE }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_EQUAL_AND_PLUS }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_BACKSPACE }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_7_AND_AMPERSAND }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_8_AND_ASTERISK }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_9_AND_OPENING_PARENTHESIS }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_0_AND_CLOSING_PARENTHESIS }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_MINUS_AND_UNDERSCORE }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_EQUAL_AND_PLUS }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_BACKSPACE }},

            // Row 2
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_U }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_I }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_O }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_P }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_OPENING_BRACKET_AND_OPENING_BRACE }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_CLOSING_BRACKET_AND_CLOSING_BRACE }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_BACKSLASH_AND_PIPE }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_Y }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_U }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_I }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_O }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_P }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_OPENING_BRACKET_AND_OPENING_BRACE }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_CLOSING_BRACKET_AND_CLOSING_BRACE }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_BACKSLASH_AND_PIPE }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_Y }},

            // Row 3
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_J }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_K }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_L }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_SEMICOLON_AND_COLON }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_APOSTROPHE_AND_QUOTE }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_ENTER }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_H }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_J }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_K }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_L }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_SEMICOLON_AND_COLON }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_APOSTROPHE_AND_QUOTE }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_ENTER }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_H }},

            // Row 4
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_N }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_M }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_COMMA_AND_LESS_THAN_SIGN }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_DOT_AND_GREATER_THAN_SIGN }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_SLASH_AND_QUESTION_MARK }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_RIGHT_SHIFT }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_N }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_M }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_COMMA_AND_LESS_THAN_SIGN }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_DOT_AND_GREATER_THAN_SIGN }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_SLASH_AND_QUESTION_MARK }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_RIGHT_SHIFT }},
            { .type = KEY_ACTION_NONE },

            // Row 5
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_SPACE }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_SPACE }},
            { .type = KEY_ACTION_SWITCH_LAYER, .switchLayer = { .layer = LAYER_ID_MOD }},
            { .type = KEY_ACTION_SWITCH_LAYER, .switchLayer = { .layer = LAYER_ID_FN }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_RIGHT_ALT }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_RIGHT_GUI }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_RIGHT_CONTROL }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_RIGHT_ALT }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_RIGHT_GUI }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_RIGHT_CONTROL }},
        },

        // Left keyboard half
        {
            // Row 1
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_GRAVE_ACCENT_AND_TILDE }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_1_AND_EXCLAMATION }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_2_AND_AT }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_3_AND_HASHMARK }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_4_AND_DOLLAR }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_5_AND_PERCENTAGE }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_6_AND_CARET }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_GRAVE_ACCENT_AND_TILDE }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_1_AND_EXCLAMATION }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_2_AND_AT }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_3_AND_HASHMARK }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_4_AND_DOLLAR }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_5_AND_PERCENTAGE }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_6_AND_CARET }},

            // Row 2
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_TAB }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_Q }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_W }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_E }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_R }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_TAB }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_Q }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_W }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_E }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_R }},
            { .type = KEY_ACTION_NONE },
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_T }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_T }},

            // Row 3
            { .type = KEY_ACTION_SWITCH_LAYER, .switchLayer = { .layer = LAYER_ID_MOUSE }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_A }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_S }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_D }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_F }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_A }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_S }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_D }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_F }},
            { .type = KEY_ACTION_NONE },
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_G }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_G }},

            // Row 4
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_LEFT_SHIFT }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_NON_US_BACKSLASH_AND_PIPE }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_Z }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_X }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_C }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_V }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_B }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_LEFT_SHIFT }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_NON_US_BACKSLASH_AND_PIPE }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_Z }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_X }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_C }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_V }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_B }},

            // Row 5
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_LEFT_CONTROL }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_LEFT_GUI }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_LEFT_ALT }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_LEFT_CONTROL }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_LEFT_GUI }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_LEFT_ALT }},
            { .type = KEY_ACTION_SWITCH_LAYER, .switchLayer = { .layer = LAYER_ID_FN }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_SPACE }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_SPACE }},
            { .type = KEY_ACTION_SWITCH_LAYER, .switchLayer = { .layer = LAYER_ID_MOD }},
            { .type = KEY_ACTION_NONE },
        }
@@ -105,32 +105,32 @@ key_action_t CurrentKeymap[LAYER_COUNT][SLOT_COUNT][MAX_KEY_COUNT_PER_MODULE] =
        // Right keyboard half
        {
            // Row 1
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_F7 }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_F8 }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_F9 }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_F10 }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_F11 }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_F12 }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_DELETE }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_F7 }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_F8 }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_F9 }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_F10 }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_F11 }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_F12 }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_DELETE }},

            // Row 2
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_HOME }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_UP_ARROW }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_END }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_DELETE }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_PRINT_SCREEN }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_SCROLL_LOCK }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_PAUSE }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_PAGE_UP }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_HOME }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_UP_ARROW }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_END }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_DELETE }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_PRINT_SCREEN }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_SCROLL_LOCK }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_PAUSE }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_PAGE_UP }},

            // Row 3
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_LEFT_ARROW }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_DOWN_ARROW }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_RIGHT_ARROW }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_INSERT }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_LEFT_ARROW }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_DOWN_ARROW }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_RIGHT_ARROW }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_INSERT }},
            { .type = KEY_ACTION_NONE },
            { .type = KEY_ACTION_NONE },
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_PAGE_DOWN }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_PAGE_DOWN }},

            // Row 4
            { .type = KEY_ACTION_NONE },
@@ -138,60 +138,60 @@ key_action_t CurrentKeymap[LAYER_COUNT][SLOT_COUNT][MAX_KEY_COUNT_PER_MODULE] =
            { .type = KEY_ACTION_NONE },
            { .type = KEY_ACTION_NONE },
            { .type = KEY_ACTION_NONE },
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_RIGHT_SHIFT }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_RIGHT_SHIFT }},
            { .type = KEY_ACTION_NONE },

            // Row 5
            { .type = KEY_ACTION_NONE },
            { .type = KEY_ACTION_SWITCH_LAYER, .switchLayer = { .layer = LAYER_ID_MOD }},
            { .type = KEY_ACTION_NONE },
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_RIGHT_ALT }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_RIGHT_GUI }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_RIGHT_CONTROL }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_RIGHT_ALT }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_RIGHT_GUI }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_RIGHT_CONTROL }},
        },

        // Left keyboard half
        {
            // Row 1
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_ESCAPE }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_F1 }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_F2 }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_F3 }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_F4 }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_F5 }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_F6 }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_ESCAPE }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_F1 }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_F2 }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_F3 }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_F4 }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_F5 }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_F6 }},

            // Row 2
            { .type = KEY_ACTION_NONE },
            { .type = KEY_ACTION_NONE },
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_PAGE_UP, .mods = HID_KEYBOARD_MODIFIER_LEFTCTRL }}, // [<] tab prev
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_T, .mods = HID_KEYBOARD_MODIFIER_LEFTCTRL }}, // [+] tab new
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_PAGE_DOWN, .mods = HID_KEYBOARD_MODIFIER_LEFTCTRL }}, // [>] tab next
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_PAGE_UP, .mods = HID_KEYBOARD_MODIFIER_LEFTCTRL }}, // [<] tab prev
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_T, .mods = HID_KEYBOARD_MODIFIER_LEFTCTRL }}, // [+] tab new
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_PAGE_DOWN, .mods = HID_KEYBOARD_MODIFIER_LEFTCTRL }}, // [>] tab next
            { .type = KEY_ACTION_NONE },
            { .type = KEY_ACTION_NONE },

            // Row 3
            { .type = KEY_ACTION_NONE },
            { .type = KEY_ACTION_NONE },
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_LEFT_ARROW, .mods = HID_KEYBOARD_MODIFIER_LEFTCTRL | HID_KEYBOARD_MODIFIER_LEFTALT }}, // workspace prev
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_TAB, .mods = HID_KEYBOARD_MODIFIER_LEFTALT }}, // Window switch?
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_RIGHT_ARROW, .mods = HID_KEYBOARD_MODIFIER_LEFTCTRL | HID_KEYBOARD_MODIFIER_LEFTALT }}, // workspace next
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_LEFT_ARROW, .mods = HID_KEYBOARD_MODIFIER_LEFTCTRL | HID_KEYBOARD_MODIFIER_LEFTALT }}, // workspace prev
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_TAB, .mods = HID_KEYBOARD_MODIFIER_LEFTALT }}, // Window switch?
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_RIGHT_ARROW, .mods = HID_KEYBOARD_MODIFIER_LEFTCTRL | HID_KEYBOARD_MODIFIER_LEFTALT }}, // workspace next
            { .type = KEY_ACTION_NONE },
            { .type = KEY_ACTION_NONE },

            // Row 4
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_LEFT_SHIFT }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_LEFT_SHIFT }},
            { .type = KEY_ACTION_NONE },
            { .type = KEY_ACTION_NONE },
            { .type = KEY_ACTION_NONE },
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_W, .mods = HID_KEYBOARD_MODIFIER_LEFTCTRL }}, // [x] tab close
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_W, .mods = HID_KEYBOARD_MODIFIER_LEFTCTRL }}, // [x] tab close
            { .type = KEY_ACTION_NONE },
            { .type = KEY_ACTION_NONE },

            // Row 5
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_LEFT_CONTROL }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_LEFT_GUI }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_LEFT_ALT }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_LEFT_CONTROL }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_LEFT_GUI }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_LEFT_ALT }},
            { .type = KEY_ACTION_NONE },
            { .type = KEY_ACTION_NONE },
            { .type = KEY_ACTION_SWITCH_LAYER, .switchLayer = { .layer = LAYER_ID_MOD }},
@@ -213,19 +213,19 @@ key_action_t CurrentKeymap[LAYER_COUNT][SLOT_COUNT][MAX_KEY_COUNT_PER_MODULE] =
            { .type = KEY_ACTION_NONE },

            // Row 2
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_MEDIA_PLAY }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_MEDIA_VOLUME_UP }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_MEDIA_STOP }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_MEDIA_PLAY }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_MEDIA_VOLUME_UP }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_MEDIA_STOP }},
            { .type = KEY_ACTION_NONE },
            { .type = KEY_ACTION_NONE },
            { .type = KEY_ACTION_NONE },
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_MEDIA_SLEEP }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_MEDIA_SLEEP }},
            { .type = KEY_ACTION_NONE },

            // Row 3
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_MEDIA_PREVIOUS_TRACK }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_MEDIA_VOLUME_DOWN }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_MEDIA_NEXT_TRACK }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_MEDIA_PREVIOUS_TRACK }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_MEDIA_VOLUME_DOWN }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_MEDIA_NEXT_TRACK }},
            { .type = KEY_ACTION_NONE },
            { .type = KEY_ACTION_NONE },
            { .type = KEY_ACTION_NONE },
@@ -234,19 +234,19 @@ key_action_t CurrentKeymap[LAYER_COUNT][SLOT_COUNT][MAX_KEY_COUNT_PER_MODULE] =
            // Row 4
            { .type = KEY_ACTION_NONE },
            { .type = KEY_ACTION_NONE },
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_MEDIA_MUTE }},
+            { .type = KEY_ACTION_MEDIA_KEYSTROKE, .keystroke = { .key = /*HID_KEYBOARD_SC_MEDIA_MUTE*/0xe2 }},
            { .type = KEY_ACTION_NONE },
            { .type = KEY_ACTION_NONE },
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_RIGHT_SHIFT }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_RIGHT_SHIFT }},
            { .type = KEY_ACTION_NONE },

            // Row 5
            { .type = KEY_ACTION_NONE },
            { .type = KEY_ACTION_NONE },
            { .type = KEY_ACTION_SWITCH_LAYER, .switchLayer = { .layer = LAYER_ID_FN }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_RIGHT_ALT }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_RIGHT_GUI }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_RIGHT_CONTROL }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_RIGHT_ALT }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_RIGHT_GUI }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_RIGHT_CONTROL }},
        },

        // Left keyboard half
@@ -263,8 +263,8 @@ key_action_t CurrentKeymap[LAYER_COUNT][SLOT_COUNT][MAX_KEY_COUNT_PER_MODULE] =
            // Row 2
            { .type = KEY_ACTION_NONE },
            { .type = KEY_ACTION_NONE },
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_MEDIA_STOP }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_MEDIA_RELOAD }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_MEDIA_STOP }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_MEDIA_RELOAD }},
            { .type = KEY_ACTION_NONE },
            { .type = KEY_ACTION_NONE },
            { .type = KEY_ACTION_NONE },
@@ -273,24 +273,24 @@ key_action_t CurrentKeymap[LAYER_COUNT][SLOT_COUNT][MAX_KEY_COUNT_PER_MODULE] =
            { .type = KEY_ACTION_NONE },
            { .type = KEY_ACTION_NONE },
            { .type = KEY_ACTION_NONE }, // TODO: hist-
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_MEDIA_WWW }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_MEDIA_WWW }},
            { .type = KEY_ACTION_NONE }, // TODO: hist+
            { .type = KEY_ACTION_NONE },
            { .type = KEY_ACTION_NONE },

            // Row 4
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_LEFT_SHIFT }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_MEDIA_LOCK }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_MEDIA_SEARCH }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_MEDIA_CALCULATOR }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_MEDIA_EJECT }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_LEFT_SHIFT }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_MEDIA_LOCK }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_MEDIA_SEARCH }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_MEDIA_CALCULATOR }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_MEDIA_EJECT }},
            { .type = KEY_ACTION_NONE },
            { .type = KEY_ACTION_NONE },

            // Row 5
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_LEFT_CONTROL }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_LEFT_GUI }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_LEFT_ALT }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_LEFT_CONTROL }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_LEFT_GUI }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_LEFT_ALT }},
            { .type = KEY_ACTION_SWITCH_LAYER, .switchLayer = { .layer = LAYER_ID_FN }},
            { .type = KEY_ACTION_NONE },
            { .type = KEY_ACTION_NONE },
@@ -336,16 +336,16 @@ key_action_t CurrentKeymap[LAYER_COUNT][SLOT_COUNT][MAX_KEY_COUNT_PER_MODULE] =
            { .type = KEY_ACTION_NONE },
            { .type = KEY_ACTION_NONE },
            { .type = KEY_ACTION_NONE },
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_RIGHT_SHIFT }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_RIGHT_SHIFT }},
            { .type = KEY_ACTION_NONE },

            // Row 5
            { .type = KEY_ACTION_NONE },
            { .type = KEY_ACTION_NONE },
            { .type = KEY_ACTION_NONE },
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_RIGHT_ALT }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_RIGHT_GUI }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_RIGHT_CONTROL }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_RIGHT_ALT }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_RIGHT_GUI }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_RIGHT_CONTROL }},
        },

        // Left keyboard half
@@ -378,7 +378,7 @@ key_action_t CurrentKeymap[LAYER_COUNT][SLOT_COUNT][MAX_KEY_COUNT_PER_MODULE] =
            { .type = KEY_ACTION_NONE },

            // Row 4
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_LEFT_SHIFT }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_LEFT_SHIFT }},
            { .type = KEY_ACTION_NONE },
            { .type = KEY_ACTION_NONE },
            { .type = KEY_ACTION_NONE },
@@ -387,9 +387,9 @@ key_action_t CurrentKeymap[LAYER_COUNT][SLOT_COUNT][MAX_KEY_COUNT_PER_MODULE] =
            { .type = KEY_ACTION_NONE },

            // Row 5
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_LEFT_CONTROL }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_LEFT_GUI }},
-            { .type = KEY_ACTION_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_LEFT_ALT }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_LEFT_CONTROL }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_LEFT_GUI }},
+            { .type = KEY_ACTION_BASIC_KEYSTROKE, .keystroke = { .key = HID_KEYBOARD_SC_LEFT_ALT }},
            { .type = KEY_ACTION_NONE },
            { .type = KEY_ACTION_MOUSE, .mouse = { .moveActions = MOUSE_DECELERATE }},
            { .type = KEY_ACTION_MOUSE, .mouse = { .moveActions = MOUSE_ACCELERATE }},
--- a/right/src/deserialize.c
+++ b/right/src/deserialize.c
@@ -106,7 +106,7 @@ static void processNoneAction(key_action_t *action, serialized_buffer_t *buffer)
 static void processKeyStrokeAction(key_action_t *action, uint8_t actionType, serialized_buffer_t *buffer) {
    uint8_t flags = actionType - 1;

-    action->type = KEY_ACTION_KEYSTROKE;
+    action->type = KEY_ACTION_BASIC_KEYSTROKE;

    if (flags & HAS_SCANCODE) {
        action->keystroke.key = readUInt8(buffer);
--- a/right/src/main.c
+++ b/right/src/main.c
@@ -7,7 +7,8 @@
 #include "action.h"
 #include "bridge_protocol_scheduler.h"
 #include "peripherials/test_led.h"
-#include "usb_interfaces/usb_interface_keyboard.h"
+#include "usb_interfaces/usb_interface_basic_keyboard.h"
+#include "usb_interfaces/usb_interface_media_keyboard.h"

 key_matrix_t KeyMatrix = {
    .colNum = KEYBOARD_MATRIX_COLS_NUM,
@@ -63,17 +64,19 @@ static const uint8_t testData[] =

 void UpdateUsbReports()
 {
-    if (!IsUsbKeyboardReportSent) {
+    if (!IsUsbBasicKeyboardReportSent) {
        return;
    }

-    ResetActiveUsbKeyboardReport();
+    ResetActiveUsbBasicKeyboardReport();
+    ResetActiveUsbMediaKeyboardReport();
    KeyMatrix_Scan(&KeyMatrix);
    memcpy(CurrentKeyStates[SLOT_ID_RIGHT_KEYBOARD_HALF], KeyMatrix.keyStates, MAX_KEY_COUNT_PER_MODULE);
    UpdateActiveUsbReports();
-    SwitchActiveUsbKeyboardReport();
+    SwitchActiveUsbBasicKeyboardReport();
+    SwitchActiveUsbMediaKeyboardReport();

-    IsUsbKeyboardReportSent = false;
+    IsUsbBasicKeyboardReportSent = false;
 }

 void main() {
--- a/right/src/usb_api.h
+++ b/right/src/usb_api.h
@@ -49,6 +49,7 @@
    #define HID_RI_USAGE_GENERIC_DESKTOP_JOYSTICK              0x04
    #define HID_RI_USAGE_GENERIC_DESKTOP_GAMEPAD               0x05
    #define HID_RI_USAGE_GENERIC_DESKTOP_KEYBOARD              0x06
+    #define HID_RI_USAGE_GENERIC_DESKTOP_CONSUMER              0x0C
    #define HID_RI_USAGE_GENERIC_DESKTOP_X                     0x30
    #define HID_RI_USAGE_GENERIC_DESKTOP_Y                     0x31
    #define HID_RI_USAGE_GENERIC_DESKTOP_WHEEL                 0x38
--- a/right/src/usb_composite_device.c
+++ b/right/src/usb_composite_device.c
@@ -9,8 +9,9 @@ usb_composite_device_t UsbCompositeDevice;

 usb_device_class_config_struct_t UsbDeviceCompositeClassConfig[USB_DEVICE_CONFIG_HID] = {
    {UsbGenericHidCallback, (class_handle_t)NULL, &UsbGenericHidClass},
-    {UsbKeyboardCallback,   (class_handle_t)NULL, &UsbKeyboardClass},
+    {UsbBasicKeyboardCallback,   (class_handle_t)NULL, &UsbBasicKeyboardClass},
    {UsbMouseCallback,      (class_handle_t)NULL, &UsbMouseClass},
+    {UsbMediaKeyboardCallback,   (class_handle_t)NULL, &UsbMediaKeyboardClass},
 };

 usb_device_class_config_list_struct_t UsbDeviceCompositeConfigList = {
@@ -38,9 +39,10 @@ static usb_status_t UsbDeviceCallback(usb_device_handle handle, uint32_t event,
            UsbCompositeDevice.attach = 1;
            UsbCompositeDevice.currentConfiguration = *temp8;
            UsbGenericHidSetConfiguration(UsbCompositeDevice.genericHidHandle, *temp8);
-            UsbKeyboardSetConfiguration(UsbCompositeDevice.keyboardHandle, *temp8);
+            UsbBasicKeyboardSetConfiguration(UsbCompositeDevice.basicKeyboardHandle, *temp8);
            UsbMouseSetConfiguration(UsbCompositeDevice.mouseHandle, *temp8);
-            error = kStatus_USB_Success;
+            UsbMediaKeyboardSetConfiguration(UsbCompositeDevice.mediaKeyboardHandle, *temp8);
+             error = kStatus_USB_Success;
            break;
        case kUSB_DeviceEventGetConfiguration:
            *temp8 = UsbCompositeDevice.currentConfiguration;
@@ -53,8 +55,9 @@ static usb_status_t UsbDeviceCallback(usb_device_handle handle, uint32_t event,
                if (interface < USB_DEVICE_CONFIG_HID) {
                    UsbCompositeDevice.currentInterfaceAlternateSetting[interface] = alternateSetting;
                    UsbGenericHidSetInterface(UsbCompositeDevice.genericHidHandle, interface, alternateSetting);
-                    UsbKeyboardSetInterface(UsbCompositeDevice.keyboardHandle, interface, alternateSetting);
+                    UsbBasicKeyboardSetInterface(UsbCompositeDevice.basicKeyboardHandle, interface, alternateSetting);
                    UsbMouseSetInterface(UsbCompositeDevice.mouseHandle, interface, alternateSetting);
+                    UsbMediaKeyboardSetInterface(UsbCompositeDevice.mediaKeyboardHandle, interface, alternateSetting);
                    error = kStatus_USB_Success;
                }
            }
@@ -107,8 +110,9 @@ void InitUsb()
    UsbCompositeDevice.attach = 0;
    USB_DeviceClassInit(CONTROLLER_ID, &UsbDeviceCompositeConfigList, &UsbCompositeDevice.deviceHandle);
    UsbCompositeDevice.genericHidHandle = UsbDeviceCompositeConfigList.config[USB_GENERIC_HID_INTERFACE_INDEX].classHandle;
-    UsbCompositeDevice.keyboardHandle = UsbDeviceCompositeConfigList.config[USB_KEYBOARD_INTERFACE_INDEX].classHandle;
+    UsbCompositeDevice.basicKeyboardHandle = UsbDeviceCompositeConfigList.config[USB_BASIC_KEYBOARD_INTERFACE_INDEX].classHandle;
    UsbCompositeDevice.mouseHandle = UsbDeviceCompositeConfigList.config[USB_MOUSE_INTERFACE_INDEX].classHandle;
+    UsbCompositeDevice.mediaKeyboardHandle = UsbDeviceCompositeConfigList.config[USB_MEDIA_KEYBOARD_INTERFACE_INDEX].classHandle;

    NVIC_SetPriority((IRQn_Type)irqNumber, USB_DEVICE_INTERRUPT_PRIORITY);
    NVIC_EnableIRQ((IRQn_Type)irqNumber);
--- a/right/src/usb_composite_device.h
+++ b/right/src/usb_composite_device.h
@@ -15,8 +15,9 @@
    typedef struct {
        usb_device_handle deviceHandle;
        class_handle_t mouseHandle;
-        class_handle_t keyboardHandle;
+        class_handle_t basicKeyboardHandle;
        class_handle_t genericHidHandle;
+        class_handle_t mediaKeyboardHandle;
        uint8_t attach;
        uint8_t currentConfiguration;
        uint8_t currentInterfaceAlternateSetting[USB_DEVICE_CONFIG_HID];
--- a/right/src/usb_descriptors/usb_descriptor_basic_keyboard_report.c
+++ b/right/src/usb_descriptors/usb_descriptor_basic_keyboard_report.c
@@ -1,7 +1,7 @@
 #include "usb_api.h"
-#include "usb_descriptor_keyboard_report.h"
+#include "usb_descriptor_basic_keyboard_report.h"

-uint8_t UsbKeyboardReportDescriptor[USB_KEYBOARD_REPORT_DESCRIPTOR_LENGTH] = {
+uint8_t UsbBasicKeyboardReportDescriptor[USB_BASIC_KEYBOARD_REPORT_DESCRIPTOR_LENGTH] = {
    HID_RI_USAGE_PAGE(8, HID_RI_USAGE_PAGE_GENERIC_DESKTOP),
    HID_RI_USAGE(8, HID_RI_USAGE_GENERIC_DESKTOP_KEYBOARD),
    HID_RI_COLLECTION(8, HID_RI_COLLECTION_APPLICATION),
@@ -40,7 +40,7 @@ uint8_t UsbKeyboardReportDescriptor[USB_KEYBOARD_REPORT_DESCRIPTOR_LENGTH] = {
        HID_RI_USAGE_PAGE(8, HID_RI_USAGE_PAGE_KEY_CODES),
        HID_RI_USAGE_MINIMUM(8, 0x00),
        HID_RI_USAGE_MAXIMUM(8, 0xFF),
-        HID_RI_REPORT_COUNT(8, USB_KEYBOARD_MAX_KEYS),
+        HID_RI_REPORT_COUNT(8, USB_BASIC_KEYBOARD_MAX_KEYS),
        HID_RI_REPORT_SIZE(8, 0x08),
        HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_ARRAY | HID_IOF_ABSOLUTE),

--- a/right/src/usb_descriptors/usb_descriptor_basic_keyboard_report.h
+++ b/right/src/usb_descriptors/usb_descriptor_basic_keyboard_report.h
@@ -0,0 +1,13 @@
+#ifndef __USB_DESCRIPTOR_BASIC_KEYBOARD_REPORT_H__
+#define __USB_DESCRIPTOR_BASIC_KEYBOARD_REPORT_H__
+
+// Macros:
+
+    #define USB_BASIC_KEYBOARD_REPORT_DESCRIPTOR_LENGTH 63
+    #define USB_BASIC_KEYBOARD_MAX_KEYS 6
+
+// Variables:
+
+    extern uint8_t UsbBasicKeyboardReportDescriptor[USB_BASIC_KEYBOARD_REPORT_DESCRIPTOR_LENGTH];
+
+#endif
--- a/right/src/usb_descriptors/usb_descriptor_configuration.c
+++ b/right/src/usb_descriptors/usb_descriptor_configuration.c
@@ -63,19 +63,19 @@ uint8_t UsbConfigurationDescriptor[USB_CONFIGURATION_DESCRIPTOR_TOTAL_LENGTH] =
    USB_SHORT_GET_HIGH(USB_GENERIC_HID_INTERRUPT_OUT_PACKET_SIZE),
    USB_GENERIC_HID_INTERRUPT_IN_INTERVAL,

-// Keyboard interface descriptor
+// Basic keyboard interface descriptor

    USB_DESCRIPTOR_LENGTH_INTERFACE,
    USB_DESCRIPTOR_TYPE_INTERFACE,
-    USB_KEYBOARD_INTERFACE_INDEX,
+    USB_BASIC_KEYBOARD_INTERFACE_INDEX,
    USB_INTERFACE_ALTERNATE_SETTING_NONE,
-    USB_KEYBOARD_ENDPOINT_COUNT,
+    USB_BASIC_KEYBOARD_ENDPOINT_COUNT,
    USB_CLASS_HID,
    USB_HID_SUBCLASS_BOOT,
    USB_HID_PROTOCOL_KEYBOARD,
    USB_STRING_DESCRIPTOR_NONE,

-// Keyboard HID descriptor
+// Basic keyboard HID descriptor

    USB_DESCRIPTOR_LENGTH_HID,
    USB_DESCRIPTOR_TYPE_HID,
@@ -84,18 +84,18 @@ uint8_t UsbConfigurationDescriptor[USB_CONFIGURATION_DESCRIPTOR_TOTAL_LENGTH] =
    USB_HID_COUNTRY_CODE_NOT_SUPPORTED,
    USB_REPORT_DESCRIPTOR_COUNT_PER_HID_DEVICE,
    USB_DESCRIPTOR_TYPE_HID_REPORT,
-    USB_SHORT_GET_LOW(USB_KEYBOARD_REPORT_DESCRIPTOR_LENGTH),
-    USB_SHORT_GET_HIGH(USB_KEYBOARD_REPORT_DESCRIPTOR_LENGTH),
+    USB_SHORT_GET_LOW(USB_BASIC_KEYBOARD_REPORT_DESCRIPTOR_LENGTH),
+    USB_SHORT_GET_HIGH(USB_BASIC_KEYBOARD_REPORT_DESCRIPTOR_LENGTH),

-// Keyboard endpoint descriptor
+// Basic keyboard endpoint descriptor

    USB_DESCRIPTOR_LENGTH_ENDPOINT,
    USB_DESCRIPTOR_TYPE_ENDPOINT,
-    USB_KEYBOARD_ENDPOINT_INDEX | (USB_IN << USB_DESCRIPTOR_ENDPOINT_ADDRESS_DIRECTION_SHIFT),
+    USB_BASIC_KEYBOARD_ENDPOINT_INDEX | (USB_IN << USB_DESCRIPTOR_ENDPOINT_ADDRESS_DIRECTION_SHIFT),
    USB_ENDPOINT_INTERRUPT,
-    USB_SHORT_GET_LOW(USB_KEYBOARD_INTERRUPT_IN_PACKET_SIZE),
-    USB_SHORT_GET_HIGH(USB_KEYBOARD_INTERRUPT_IN_PACKET_SIZE),
-    USB_KEYBOARD_INTERRUPT_IN_INTERVAL,
+    USB_SHORT_GET_LOW(USB_BASIC_KEYBOARD_INTERRUPT_IN_PACKET_SIZE),
+    USB_SHORT_GET_HIGH(USB_BASIC_KEYBOARD_INTERRUPT_IN_PACKET_SIZE),
+    USB_BASIC_KEYBOARD_INTERRUPT_IN_INTERVAL,

 // Mouse interface descriptor

@@ -130,6 +130,42 @@ uint8_t UsbConfigurationDescriptor[USB_CONFIGURATION_DESCRIPTOR_TOTAL_LENGTH] =
    USB_SHORT_GET_LOW(USB_MOUSE_INTERRUPT_IN_PACKET_SIZE),
    USB_SHORT_GET_HIGH(USB_MOUSE_INTERRUPT_IN_PACKET_SIZE),
    USB_MOUSE_INTERRUPT_IN_INTERVAL,
+
+// Media keyboard interface descriptor
+
+    USB_DESCRIPTOR_LENGTH_INTERFACE,
+    USB_DESCRIPTOR_TYPE_INTERFACE,
+    USB_MEDIA_KEYBOARD_INTERFACE_INDEX,
+    USB_INTERFACE_ALTERNATE_SETTING_NONE,
+    USB_MEDIA_KEYBOARD_ENDPOINT_COUNT,
+    USB_CLASS_HID,
+//    USB_HID_SUBCLASS_NONE, ////
+//    USB_HID_PROTOCOL_NONE, ////
+    USB_HID_SUBCLASS_BOOT,
+    USB_HID_PROTOCOL_KEYBOARD,
+    USB_STRING_DESCRIPTOR_NONE,
+
+// Media keyboard HID descriptor
+
+    USB_DESCRIPTOR_LENGTH_HID,
+    USB_DESCRIPTOR_TYPE_HID,
+    USB_SHORT_GET_LOW(USB_HID_VERSION),
+    USB_SHORT_GET_HIGH(USB_HID_VERSION),
+    USB_HID_COUNTRY_CODE_NOT_SUPPORTED,
+    USB_REPORT_DESCRIPTOR_COUNT_PER_HID_DEVICE,
+    USB_DESCRIPTOR_TYPE_HID_REPORT,
+    USB_SHORT_GET_LOW(USB_MEDIA_KEYBOARD_REPORT_DESCRIPTOR_LENGTH),
+    USB_SHORT_GET_HIGH(USB_MEDIA_KEYBOARD_REPORT_DESCRIPTOR_LENGTH),
+
+// Media keyboard endpoint descriptor
+
+    USB_DESCRIPTOR_LENGTH_ENDPOINT,
+    USB_DESCRIPTOR_TYPE_ENDPOINT,
+    USB_MEDIA_KEYBOARD_ENDPOINT_INDEX | (USB_IN << USB_DESCRIPTOR_ENDPOINT_ADDRESS_DIRECTION_SHIFT),
+    USB_ENDPOINT_INTERRUPT,
+    USB_SHORT_GET_LOW(USB_MEDIA_KEYBOARD_INTERRUPT_IN_PACKET_SIZE),
+    USB_SHORT_GET_HIGH(USB_MEDIA_KEYBOARD_INTERRUPT_IN_PACKET_SIZE),
+    USB_MEDIA_KEYBOARD_INTERRUPT_IN_INTERVAL,
 };

 usb_status_t USB_DeviceGetConfigurationDescriptor(
--- a/right/src/usb_descriptors/usb_descriptor_configuration.h
+++ b/right/src/usb_descriptors/usb_descriptor_configuration.h
@@ -3,14 +3,15 @@

 // Includes:

-    #include "usb_interfaces/usb_interface_keyboard.h"
+    #include "usb_interfaces/usb_interface_basic_keyboard.h"
+    #include "usb_interfaces/usb_interface_media_keyboard.h"
    #include "usb_interfaces/usb_interface_mouse.h"
    #include "usb_interfaces/usb_interface_generic_hid.h"

 // Macros:

    #define USB_COMPOSITE_CONFIGURATION_INDEX 1
-    #define USB_CONFIGURATION_DESCRIPTOR_TOTAL_LENGTH 91
+    #define USB_CONFIGURATION_DESCRIPTOR_TOTAL_LENGTH 116

 // Functions:

--- a/right/src/usb_descriptors/usb_descriptor_hid.c
+++ b/right/src/usb_descriptors/usb_descriptor_hid.c
@@ -15,9 +15,12 @@ usb_status_t USB_DeviceGetHidReportDescriptor(
    if (USB_MOUSE_INTERFACE_INDEX == hidReportDescriptor->interfaceNumber) {
        hidReportDescriptor->buffer = UsbMouseReportDescriptor;
        hidReportDescriptor->length = USB_MOUSE_REPORT_DESCRIPTOR_LENGTH;
-    } else if (USB_KEYBOARD_INTERFACE_INDEX == hidReportDescriptor->interfaceNumber) {
-        hidReportDescriptor->buffer = UsbKeyboardReportDescriptor;
-        hidReportDescriptor->length = USB_KEYBOARD_REPORT_DESCRIPTOR_LENGTH;
+    } else if (USB_BASIC_KEYBOARD_INTERFACE_INDEX == hidReportDescriptor->interfaceNumber) {
+        hidReportDescriptor->buffer = UsbBasicKeyboardReportDescriptor;
+        hidReportDescriptor->length = USB_BASIC_KEYBOARD_REPORT_DESCRIPTOR_LENGTH;
+    } else if (USB_MEDIA_KEYBOARD_INTERFACE_INDEX == hidReportDescriptor->interfaceNumber) {
+        hidReportDescriptor->buffer = UsbMediaKeyboardReportDescriptor;
+        hidReportDescriptor->length = USB_MEDIA_KEYBOARD_REPORT_DESCRIPTOR_LENGTH;
    } else if (USB_GENERIC_HID_INTERFACE_INDEX == hidReportDescriptor->interfaceNumber) {
        hidReportDescriptor->buffer = UsbGenericHidReportDescriptor;
        hidReportDescriptor->length = USB_GENERIC_HID_REPORT_DESCRIPTOR_LENGTH;
--- a/right/src/usb_descriptors/usb_descriptor_hid.h
+++ b/right/src/usb_descriptors/usb_descriptor_hid.h
@@ -3,7 +3,8 @@

 // Includes:

-    #include "usb_interfaces/usb_interface_keyboard.h"
+    #include "usb_interfaces/usb_interface_basic_keyboard.h"
+    #include "usb_interfaces/usb_interface_media_keyboard.h"
    #include "usb_interfaces/usb_interface_mouse.h"
    #include "usb_interfaces/usb_interface_generic_hid.h"

--- a/right/src/usb_descriptors/usb_descriptor_keyboard_report.h
+++ b/right/src/usb_descriptors/usb_descriptor_keyboard_report.h
@@ -1,13 +0,0 @@
-#ifndef __USB_DESCRIPTOR_KEYBOARD_REPORT_H__
-#define __USB_DESCRIPTOR_KEYBOARD_REPORT_H__
-
-// Macros:
-
-    #define USB_KEYBOARD_REPORT_DESCRIPTOR_LENGTH 63
-    #define USB_KEYBOARD_MAX_KEYS 6
-
-// Variables:
-
-    extern uint8_t UsbKeyboardReportDescriptor[USB_KEYBOARD_REPORT_DESCRIPTOR_LENGTH];
-
-#endif
--- a/right/src/usb_descriptors/usb_descriptor_media_keyboard_report.c
+++ b/right/src/usb_descriptors/usb_descriptor_media_keyboard_report.c
@@ -0,0 +1,37 @@
+#include "usb_api.h"
+#include "usb_descriptor_media_keyboard_report.h"
+
+uint8_t UsbMediaKeyboardReportDescriptor[USB_MEDIA_KEYBOARD_REPORT_DESCRIPTOR_LENGTH] = {
+    // Consumer Control (Sound/Media keys)
+    0x05, 0x0C,                                 // usage page (consumer device)
+    0x09, 0x01,                                 // usage -- consumer control
+    0xA1, 0x01,                                 // collection (application)
+    // 4 Media Keys
+    0x15, 0x00,                                 // logical minimum
+    0x26, 0xFF, 0x03,                           // logical maximum (3ff)
+    0x19, 0x00,                                 // usage minimum (0)
+    0x2A, 0xFF, 0x03,                           // usage maximum (3ff)
+    0x95, 0x04,                                 // report count (4)
+    0x75, 0x10,                                 // report size (16)
+    0x81, 0x00,                                 // input
+    0xC0 // end collection
+};
+
+/*
+uint8_t UsbMediaKeyboardReportDescriptor[USB_MEDIA_KEYBOARD_REPORT_DESCRIPTOR_LENGTH] = {
+    HID_RI_USAGE_PAGE(8, HID_RI_USAGE_PAGE_CONSUMER),
+    HID_RI_USAGE(8, 0x01),
+    HID_RI_COLLECTION(8, HID_RI_COLLECTION_APPLICATION),
+        // Scancodes
+        HID_RI_LOGICAL_MINIMUM(8, 0x00),
+        HID_RI_LOGICAL_MAXIMUM(8, 0xFF),
+        HID_RI_USAGE_PAGE(8, HID_RI_USAGE_PAGE_KEY_CODES),
+        HID_RI_USAGE_MINIMUM(8, 0x00),
+        HID_RI_USAGE_MAXIMUM(8, 0xFF),
+        HID_RI_REPORT_COUNT(8, USB_MEDIA_KEYBOARD_MAX_KEYS),
+        HID_RI_REPORT_SIZE(8, 0x08),
+        HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_ARRAY | HID_IOF_ABSOLUTE),
+
+    HID_RI_END_COLLECTION(0),
+};
+*/
--- a/right/src/usb_descriptors/usb_descriptor_media_keyboard_report.h
+++ b/right/src/usb_descriptors/usb_descriptor_media_keyboard_report.h
@@ -0,0 +1,13 @@
+#ifndef __USB_DESCRIPTOR_MEDIA_KEYBOARD_REPORT_H__
+#define __USB_DESCRIPTOR_MEDIA_KEYBOARD_REPORT_H__
+
+// Macros:
+
+    #define USB_MEDIA_KEYBOARD_REPORT_DESCRIPTOR_LENGTH 23
+    #define USB_MEDIA_KEYBOARD_MAX_KEYS 4
+
+// Variables:
+
+    extern uint8_t UsbMediaKeyboardReportDescriptor[USB_MEDIA_KEYBOARD_REPORT_DESCRIPTOR_LENGTH];
+
+#endif
--- a/right/src/usb_device_config.h
+++ b/right/src/usb_device_config.h
@@ -8,11 +8,12 @@
 #define USB_DEVICE_CONFIG_NUM 1

 // HID instance count
-#define USB_KEYBOARD_INTERFACE_COUNT 1
+#define USB_BASIC_KEYBOARD_INTERFACE_COUNT 1
+#define USB_MEDIA_KEYBOARD_INTERFACE_COUNT 1
 #define USB_MOUSE_INTERFACE_COUNT 1
 #define USB_GENERIC_HID_INTERFACE_COUNT 1
 #define USB_DEVICE_CONFIG_HID \
-    (USB_KEYBOARD_INTERFACE_COUNT + USB_MOUSE_INTERFACE_COUNT + USB_GENERIC_HID_INTERFACE_COUNT)
+    (USB_BASIC_KEYBOARD_INTERFACE_COUNT + USB_MEDIA_KEYBOARD_INTERFACE_COUNT + USB_MOUSE_INTERFACE_COUNT + USB_GENERIC_HID_INTERFACE_COUNT)

 // Whether the device is self-powered: 1 supported, 0 not supported
 #define USB_DEVICE_CONFIG_SELF_POWER 1
@@ -21,7 +22,7 @@
 #define USB_DEVICE_CONFIG_REMOTE_WAKEUP 0

 // How many endpoints are supported in the stack
-#define USB_DEVICE_CONFIG_ENDPOINTS 5
+#define USB_DEVICE_CONFIG_ENDPOINTS 6

 // The maximum buffer length for the KHCI DMA workaround
 #define USB_DEVICE_CONFIG_KHCI_DMA_ALIGN_BUFFER_LENGTH 64
--- a/right/src/usb_interfaces/usb_interface_basic_keyboard.c
+++ b/right/src/usb_interfaces/usb_interface_basic_keyboard.c
@@ -0,0 +1,112 @@
+#include "main.h"
+#include "action.h"
+#include "fsl_port.h"
+#include "usb_api.h"
+#include "usb_composite_device.h"
+#include "peripherials/test_led.h"
+#include "fsl_i2c.h"
+#include "i2c.h"
+#include "i2c_addresses.h"
+
+static usb_device_endpoint_struct_t UsbBasicKeyboardEndpoints[USB_BASIC_KEYBOARD_ENDPOINT_COUNT] = {{
+    USB_BASIC_KEYBOARD_ENDPOINT_INDEX | (USB_IN << USB_DESCRIPTOR_ENDPOINT_ADDRESS_DIRECTION_SHIFT),
+    USB_ENDPOINT_INTERRUPT,
+    USB_BASIC_KEYBOARD_INTERRUPT_IN_PACKET_SIZE,
+}};
+
+static usb_device_interface_struct_t UsbBasicKeyboardInterface[] = {{
+    USB_INTERFACE_ALTERNATE_SETTING_NONE,
+    {USB_BASIC_KEYBOARD_ENDPOINT_COUNT, UsbBasicKeyboardEndpoints},
+    NULL,
+}};
+
+static usb_device_interfaces_struct_t UsbBasicKeyboardInterfaces[USB_BASIC_KEYBOARD_INTERFACE_COUNT] = {{
+    USB_CLASS_HID,
+    USB_HID_SUBCLASS_BOOT,
+    USB_HID_PROTOCOL_KEYBOARD,
+    USB_BASIC_KEYBOARD_INTERFACE_INDEX,
+    UsbBasicKeyboardInterface,
+    sizeof(UsbBasicKeyboardInterface) / sizeof(usb_device_interfaces_struct_t),
+}};
+
+static usb_device_interface_list_t UsbBasicKeyboardInterfaceList[USB_DEVICE_CONFIGURATION_COUNT] = {{
+    USB_BASIC_KEYBOARD_INTERFACE_COUNT,
+    UsbBasicKeyboardInterfaces,
+}};
+
+usb_device_class_struct_t UsbBasicKeyboardClass = {
+    UsbBasicKeyboardInterfaceList,
+    kUSB_DeviceClassTypeHid,
+    USB_DEVICE_CONFIGURATION_COUNT,
+};
+
+static usb_basic_keyboard_report_t usbBasicKeyboardReports[2];
+usb_basic_keyboard_report_t* ActiveUsbBasicKeyboardReport = usbBasicKeyboardReports;
+bool IsUsbBasicKeyboardReportSent = false;
+
+usb_basic_keyboard_report_t* getInactiveUsbBasicKeyboardReport()
+{
+    return ActiveUsbBasicKeyboardReport == usbBasicKeyboardReports ? usbBasicKeyboardReports+1 : usbBasicKeyboardReports;
+}
+
+void SwitchActiveUsbBasicKeyboardReport()
+{
+    ActiveUsbBasicKeyboardReport = getInactiveUsbBasicKeyboardReport();
+}
+
+void ResetActiveUsbBasicKeyboardReport()
+{
+    bzero(ActiveUsbBasicKeyboardReport, USB_BASIC_KEYBOARD_REPORT_LENGTH);
+}
+
+static usb_status_t UsbBasicKeyboardAction(void)
+{
+    usb_status_t status = USB_DeviceHidSend(
+        UsbCompositeDevice.basicKeyboardHandle, USB_BASIC_KEYBOARD_ENDPOINT_INDEX,
+        (uint8_t*)getInactiveUsbBasicKeyboardReport(), USB_BASIC_KEYBOARD_REPORT_LENGTH);
+    IsUsbBasicKeyboardReportSent = true;
+    return status;
+}
+
+usb_status_t UsbBasicKeyboardCallback(class_handle_t handle, uint32_t event, void *param)
+{
+    usb_status_t error = kStatus_USB_Error;
+
+    switch (event) {
+        case kUSB_DeviceHidEventSendResponse:
+            if (UsbCompositeDevice.attach) {
+                return UsbBasicKeyboardAction();
+            }
+            break;
+        case kUSB_DeviceHidEventGetReport:
+        case kUSB_DeviceHidEventSetReport:
+        case kUSB_DeviceHidEventRequestReportBuffer:
+            error = kStatus_USB_InvalidRequest;
+            break;
+        case kUSB_DeviceHidEventGetIdle:
+        case kUSB_DeviceHidEventGetProtocol:
+        case kUSB_DeviceHidEventSetIdle:
+        case kUSB_DeviceHidEventSetProtocol:
+            break;
+        default:
+            break;
+    }
+
+    return error;
+}
+
+usb_status_t UsbBasicKeyboardSetConfiguration(class_handle_t handle, uint8_t configuration)
+{
+    if (USB_COMPOSITE_CONFIGURATION_INDEX == configuration) {
+        return UsbBasicKeyboardAction();
+    }
+    return kStatus_USB_Error;
+}
+
+usb_status_t UsbBasicKeyboardSetInterface(class_handle_t handle, uint8_t interface, uint8_t alternateSetting)
+{
+    if (USB_BASIC_KEYBOARD_INTERFACE_INDEX == interface) {
+        return UsbBasicKeyboardAction();
+    }
+    return kStatus_USB_Error;
+}
--- a/right/src/usb_interfaces/usb_interface_basic_keyboard.h
+++ b/right/src/usb_interfaces/usb_interface_basic_keyboard.h
@@ -0,0 +1,45 @@
+#ifndef __USB_INTERFACE_BASIC_KEYBOARD_H__
+#define __USB_INTERFACE_BASIC_KEYBOARD_H__
+
+// Includes:
+
+    #include "fsl_common.h"
+    #include "usb_api.h"
+    #include "usb_descriptors/usb_descriptor_basic_keyboard_report.h"
+
+// Macros:
+
+    #define USB_BASIC_KEYBOARD_INTERFACE_INDEX 1
+
+    #define USB_BASIC_KEYBOARD_ENDPOINT_INDEX 3
+    #define USB_BASIC_KEYBOARD_ENDPOINT_COUNT 1
+
+    #define USB_BASIC_KEYBOARD_INTERRUPT_IN_PACKET_SIZE 8
+    #define USB_BASIC_KEYBOARD_INTERRUPT_IN_INTERVAL 4
+
+    #define USB_BASIC_KEYBOARD_REPORT_LENGTH 8
+
+// Typedefs:
+
+    typedef struct {
+        uint8_t modifiers;
+        uint8_t reserved; // Always must be 0
+        uint8_t scancodes[USB_BASIC_KEYBOARD_MAX_KEYS];
+    } __attribute__ ((packed)) usb_basic_keyboard_report_t;
+
+// Variables:
+
+    extern bool IsUsbBasicKeyboardReportSent;
+    extern usb_device_class_struct_t UsbBasicKeyboardClass;
+    extern usb_basic_keyboard_report_t* ActiveUsbBasicKeyboardReport;
+
+// Functions:
+
+    extern usb_status_t UsbBasicKeyboardCallback(class_handle_t handle, uint32_t event, void *param);
+    extern usb_status_t UsbBasicKeyboardSetConfiguration(class_handle_t handle, uint8_t configuration);
+    extern usb_status_t UsbBasicKeyboardSetInterface(class_handle_t handle, uint8_t interface, uint8_t alternateSetting);
+
+    extern void ResetActiveUsbBasicKeyboardReport();
+    extern void SwitchActiveUsbBasicKeyboardReport();
+
+#endif
--- a/right/src/usb_interfaces/usb_interface_keyboard.c
+++ b/right/src/usb_interfaces/usb_interface_keyboard.c
@@ -1,112 +0,0 @@
-#include "main.h"
-#include "action.h"
-#include "fsl_port.h"
-#include "usb_api.h"
-#include "usb_composite_device.h"
-#include "peripherials/test_led.h"
-#include "fsl_i2c.h"
-#include "i2c.h"
-#include "i2c_addresses.h"
-
-static usb_device_endpoint_struct_t UsbKeyboardEndpoints[USB_KEYBOARD_ENDPOINT_COUNT] = {{
-    USB_KEYBOARD_ENDPOINT_INDEX | (USB_IN << USB_DESCRIPTOR_ENDPOINT_ADDRESS_DIRECTION_SHIFT),
-    USB_ENDPOINT_INTERRUPT,
-    USB_KEYBOARD_INTERRUPT_IN_PACKET_SIZE,
-}};
-
-static usb_device_interface_struct_t UsbKeyboardInterface[] = {{
-    USB_INTERFACE_ALTERNATE_SETTING_NONE,
-    {USB_KEYBOARD_ENDPOINT_COUNT, UsbKeyboardEndpoints},
-    NULL,
-}};
-
-static usb_device_interfaces_struct_t UsbKeyboardInterfaces[USB_KEYBOARD_INTERFACE_COUNT] = {{
-    USB_CLASS_HID,
-    USB_HID_SUBCLASS_BOOT,
-    USB_HID_PROTOCOL_KEYBOARD,
-    USB_KEYBOARD_INTERFACE_INDEX,
-    UsbKeyboardInterface,
-    sizeof(UsbKeyboardInterface) / sizeof(usb_device_interfaces_struct_t),
-}};
-
-static usb_device_interface_list_t UsbKeyboardInterfaceList[USB_DEVICE_CONFIGURATION_COUNT] = {{
-    USB_KEYBOARD_INTERFACE_COUNT,
-    UsbKeyboardInterfaces,
-}};
-
-usb_device_class_struct_t UsbKeyboardClass = {
-    UsbKeyboardInterfaceList,
-    kUSB_DeviceClassTypeHid,
-    USB_DEVICE_CONFIGURATION_COUNT,
-};
-
-static usb_keyboard_report_t usbKeyboardReports[2];
-usb_keyboard_report_t* ActiveUsbKeyboardReport = usbKeyboardReports;
-bool IsUsbKeyboardReportSent = false;
-
-usb_keyboard_report_t* getInactiveUsbKeyboardReport()
-{
-    return ActiveUsbKeyboardReport == usbKeyboardReports ? usbKeyboardReports+1 : usbKeyboardReports;
-}
-
-void SwitchActiveUsbKeyboardReport()
-{
-    ActiveUsbKeyboardReport = getInactiveUsbKeyboardReport();
-}
-
-void ResetActiveUsbKeyboardReport()
-{
-    bzero(ActiveUsbKeyboardReport, USB_KEYBOARD_REPORT_LENGTH);
-}
-
-static usb_status_t UsbKeyboardAction(void)
-{
-    usb_status_t status = USB_DeviceHidSend(
-        UsbCompositeDevice.keyboardHandle, USB_KEYBOARD_ENDPOINT_INDEX,
-        (uint8_t*)getInactiveUsbKeyboardReport(), USB_KEYBOARD_REPORT_LENGTH);
-    IsUsbKeyboardReportSent = true;
-    return status;
-}
-
-usb_status_t UsbKeyboardCallback(class_handle_t handle, uint32_t event, void *param)
-{
-    usb_status_t error = kStatus_USB_Error;
-
-    switch (event) {
-        case kUSB_DeviceHidEventSendResponse:
-            if (UsbCompositeDevice.attach) {
-                return UsbKeyboardAction();
-            }
-            break;
-        case kUSB_DeviceHidEventGetReport:
-        case kUSB_DeviceHidEventSetReport:
-        case kUSB_DeviceHidEventRequestReportBuffer:
-            error = kStatus_USB_InvalidRequest;
-            break;
-        case kUSB_DeviceHidEventGetIdle:
-        case kUSB_DeviceHidEventGetProtocol:
-        case kUSB_DeviceHidEventSetIdle:
-        case kUSB_DeviceHidEventSetProtocol:
-            break;
-        default:
-            break;
-    }
-
-    return error;
-}
-
-usb_status_t UsbKeyboardSetConfiguration(class_handle_t handle, uint8_t configuration)
-{
-    if (USB_COMPOSITE_CONFIGURATION_INDEX == configuration) {
-        return UsbKeyboardAction();
-    }
-    return kStatus_USB_Error;
-}
-
-usb_status_t UsbKeyboardSetInterface(class_handle_t handle, uint8_t interface, uint8_t alternateSetting)
-{
-    if (USB_KEYBOARD_INTERFACE_INDEX == interface) {
-        return UsbKeyboardAction();
-    }
-    return kStatus_USB_Error;
-}
--- a/right/src/usb_interfaces/usb_interface_keyboard.h
+++ b/right/src/usb_interfaces/usb_interface_keyboard.h
@@ -1,45 +0,0 @@
-#ifndef __USB_INTERFACE_KEYBOARD_H__
-#define __USB_INTERFACE_KEYBOARD_H__
-
-// Includes:
-
-    #include "fsl_common.h"
-    #include "usb_api.h"
-    #include "usb_descriptors/usb_descriptor_keyboard_report.h"
-
-// Macros:
-
-    #define USB_KEYBOARD_INTERFACE_INDEX 1
-
-    #define USB_KEYBOARD_ENDPOINT_INDEX 3
-    #define USB_KEYBOARD_ENDPOINT_COUNT 1
-
-    #define USB_KEYBOARD_INTERRUPT_IN_PACKET_SIZE 8
-    #define USB_KEYBOARD_INTERRUPT_IN_INTERVAL 4
-
-    #define USB_KEYBOARD_REPORT_LENGTH 8
-
-// Typedefs:
-
-    typedef struct {
-        uint8_t modifiers;
-        uint8_t reserved; // Always must be 0
-        uint8_t scancodes[USB_KEYBOARD_MAX_KEYS];
-    } __attribute__ ((packed)) usb_keyboard_report_t;
-
-// Variables:
-
-    extern bool IsUsbKeyboardReportSent;
-    extern usb_device_class_struct_t UsbKeyboardClass;
-    extern usb_keyboard_report_t* ActiveUsbKeyboardReport;
-
-// Functions:
-
-    extern usb_status_t UsbKeyboardCallback(class_handle_t handle, uint32_t event, void *param);
-    extern usb_status_t UsbKeyboardSetConfiguration(class_handle_t handle, uint8_t configuration);
-    extern usb_status_t UsbKeyboardSetInterface(class_handle_t handle, uint8_t interface, uint8_t alternateSetting);
-
-    extern void ResetActiveUsbKeyboardReport();
-    extern void SwitchActiveUsbKeyboardReport();
-
-#endif
--- a/right/src/usb_interfaces/usb_interface_media_keyboard.c
+++ b/right/src/usb_interfaces/usb_interface_media_keyboard.c
@@ -0,0 +1,112 @@
+#include "main.h"
+#include "action.h"
+#include "fsl_port.h"
+#include "usb_api.h"
+#include "usb_composite_device.h"
+#include "peripherials/test_led.h"
+#include "fsl_i2c.h"
+#include "i2c.h"
+#include "i2c_addresses.h"
+
+static usb_device_endpoint_struct_t UsbMediaKeyboardEndpoints[USB_MEDIA_KEYBOARD_ENDPOINT_COUNT] = {{
+    USB_MEDIA_KEYBOARD_ENDPOINT_INDEX | (USB_IN << USB_DESCRIPTOR_ENDPOINT_ADDRESS_DIRECTION_SHIFT),
+    USB_ENDPOINT_INTERRUPT,
+    USB_MEDIA_KEYBOARD_INTERRUPT_IN_PACKET_SIZE,
+}};
+
+static usb_device_interface_struct_t UsbMediaKeyboardInterface[] = {{
+    USB_INTERFACE_ALTERNATE_SETTING_NONE,
+    {USB_MEDIA_KEYBOARD_ENDPOINT_COUNT, UsbMediaKeyboardEndpoints},
+    NULL,
+}};
+
+static usb_device_interfaces_struct_t UsbMediaKeyboardInterfaces[USB_MEDIA_KEYBOARD_INTERFACE_COUNT] = {{
+    USB_CLASS_HID,
+    USB_HID_SUBCLASS_BOOT,
+    USB_HID_PROTOCOL_KEYBOARD,
+    USB_MEDIA_KEYBOARD_INTERFACE_INDEX,
+    UsbMediaKeyboardInterface,
+    sizeof(UsbMediaKeyboardInterface) / sizeof(usb_device_interfaces_struct_t),
+}};
+
+static usb_device_interface_list_t UsbMediaKeyboardInterfaceList[USB_DEVICE_CONFIGURATION_COUNT] = {{
+    USB_MEDIA_KEYBOARD_INTERFACE_COUNT,
+    UsbMediaKeyboardInterfaces,
+}};
+
+usb_device_class_struct_t UsbMediaKeyboardClass = {
+    UsbMediaKeyboardInterfaceList,
+    kUSB_DeviceClassTypeHid,
+    USB_DEVICE_CONFIGURATION_COUNT,
+};
+
+static usb_media_keyboard_report_t usbMediaKeyboardReports[2];
+usb_media_keyboard_report_t* ActiveUsbMediaKeyboardReport = usbMediaKeyboardReports;
+bool IsUsbMediaKeyboardReportSent = false;
+
+usb_media_keyboard_report_t* getInactiveUsbMediaKeyboardReport()
+{
+    return ActiveUsbMediaKeyboardReport == usbMediaKeyboardReports ? usbMediaKeyboardReports+1 : usbMediaKeyboardReports;
+}
+
+void SwitchActiveUsbMediaKeyboardReport()
+{
+    ActiveUsbMediaKeyboardReport = getInactiveUsbMediaKeyboardReport();
+}
+
+void ResetActiveUsbMediaKeyboardReport()
+{
+    bzero(ActiveUsbMediaKeyboardReport, USB_MEDIA_KEYBOARD_REPORT_LENGTH);
+}
+
+static usb_status_t UsbMediaKeyboardAction(void)
+{
+    usb_status_t status = USB_DeviceHidSend(
+        UsbCompositeDevice.mediaKeyboardHandle, USB_MEDIA_KEYBOARD_ENDPOINT_INDEX,
+        (uint8_t*)getInactiveUsbMediaKeyboardReport(), USB_MEDIA_KEYBOARD_REPORT_LENGTH);
+    IsUsbMediaKeyboardReportSent = true;
+    return status;
+}
+
+usb_status_t UsbMediaKeyboardCallback(class_handle_t handle, uint32_t event, void *param)
+{
+    usb_status_t error = kStatus_USB_Error;
+
+    switch (event) {
+        case kUSB_DeviceHidEventSendResponse:
+            if (UsbCompositeDevice.attach) {
+                return UsbMediaKeyboardAction();
+            }
+            break;
+        case kUSB_DeviceHidEventGetReport:
+        case kUSB_DeviceHidEventSetReport:
+        case kUSB_DeviceHidEventRequestReportBuffer:
+            error = kStatus_USB_InvalidRequest;
+            break;
+        case kUSB_DeviceHidEventGetIdle:
+        case kUSB_DeviceHidEventGetProtocol:
+        case kUSB_DeviceHidEventSetIdle:
+        case kUSB_DeviceHidEventSetProtocol:
+            break;
+        default:
+            break;
+    }
+
+    return error;
+}
+
+usb_status_t UsbMediaKeyboardSetConfiguration(class_handle_t handle, uint8_t configuration)
+{
+    if (USB_COMPOSITE_CONFIGURATION_INDEX == configuration) {
+        return UsbMediaKeyboardAction();
+    }
+    return kStatus_USB_Error;
+}
+
+usb_status_t UsbMediaKeyboardSetInterface(class_handle_t handle, uint8_t interface, uint8_t alternateSetting)
+{
+    if (USB_MEDIA_KEYBOARD_INTERFACE_INDEX == interface) {
+        return UsbMediaKeyboardAction();
+    }
+    return kStatus_USB_Error;
+}
--- a/right/src/usb_interfaces/usb_interface_media_keyboard.h
+++ b/right/src/usb_interfaces/usb_interface_media_keyboard.h
@@ -0,0 +1,43 @@
+#ifndef __USB_INTERFACE_MEDIA_KEYBOARD_H__
+#define __USB_INTERFACE_MEDIA_KEYBOARD_H__
+
+// Includes:
+
+    #include "fsl_common.h"
+    #include "usb_api.h"
+    #include "usb_descriptors/usb_descriptor_media_keyboard_report.h"
+
+// Macros:
+
+    #define USB_MEDIA_KEYBOARD_INTERFACE_INDEX 3
+
+    #define USB_MEDIA_KEYBOARD_ENDPOINT_INDEX 5
+    #define USB_MEDIA_KEYBOARD_ENDPOINT_COUNT 1
+
+    #define USB_MEDIA_KEYBOARD_INTERRUPT_IN_PACKET_SIZE 8
+    #define USB_MEDIA_KEYBOARD_INTERRUPT_IN_INTERVAL 4
+
+    #define USB_MEDIA_KEYBOARD_REPORT_LENGTH 8
+
+// Typedefs:
+
+    typedef struct {
+        uint16_t scancodes[USB_MEDIA_KEYBOARD_MAX_KEYS];
+    } __attribute__ ((packed)) usb_media_keyboard_report_t;
+
+// Variables:
+
+    extern bool IsUsbMediaKeyboardReportSent;
+    extern usb_device_class_struct_t UsbMediaKeyboardClass;
+    extern usb_media_keyboard_report_t* ActiveUsbMediaKeyboardReport;
+
+// Functions:
+
+    extern usb_status_t UsbMediaKeyboardCallback(class_handle_t handle, uint32_t event, void *param);
+    extern usb_status_t UsbMediaKeyboardSetConfiguration(class_handle_t handle, uint8_t configuration);
+    extern usb_status_t UsbMediaKeyboardSetInterface(class_handle_t handle, uint8_t interface, uint8_t alternateSetting);
+
+    extern void ResetActiveUsbMediaKeyboardReport();
+    extern void SwitchActiveUsbMediaKeyboardReport();
+
+#endif
--- a/right/src/usb_report_updater.c
+++ b/right/src/usb_report_updater.c
@@ -95,10 +95,13 @@ void UpdateActiveUsbReports() {

            key_action_t action = CurrentKeymap[activeLayer][slotId][keyId];
            switch (action.type) {
-                case KEY_ACTION_KEYSTROKE:
-                    ActiveUsbKeyboardReport->scancodes[scancodeIdx++] = action.keystroke.key;
-                    ActiveUsbKeyboardReport->modifiers |= action.keystroke.mods;
-                    break;
+            case KEY_ACTION_BASIC_KEYSTROKE:
+                ActiveUsbBasicKeyboardReport->scancodes[scancodeIdx++] = action.keystroke.key;
+                ActiveUsbBasicKeyboardReport->modifiers |= action.keystroke.mods;
+                break;
+            case KEY_ACTION_MEDIA_KEYSTROKE:
+                ActiveUsbMediaKeyboardReport->scancodes[scancodeIdx++] = action.keystroke.key;
+                break;
                case KEY_ACTION_MOUSE:
                    processMouseAction(action);
                    break;