@ -0,0 +1,59 @@ | |||
# Space Cadet: The Future, Built In | |||
Steve Losh described the [Space Cadet Shift](http://stevelosh.com/blog/2012/10/a-modern-space-cadet/) quite well. Essentially, when you tap Left Shift on its own, you get an opening parenthesis; tap Right Shift on its own and you get the closing one. When held, the Shift keys function as normal. Yes, it's as cool as it sounds, and now even cooler supporting Control and Alt as well! | |||
## Usage | |||
Firstly, in your keymap, do one of the following: | |||
- Replace the Left Shift key with `KC_LSPO` (Left Shift, Parenthesis Open), and Right Shift with `KC_RSPC` (Right Shift, Parenthesis Close). | |||
- Replace the Left Control key with `KC_LCPO` (Left Control, Parenthesis Open), and Right Control with `KC_RCPC` (Right Control, Parenthesis Close). | |||
- Replace the Left Alt key with `KC_LAPO` (Left Alt, Parenthesis Open), and Right Alt with `KC_RAPC` (Right Alt, Parenthesis Close). | |||
- Replace any Shift key in your keymap with `KC_SFTENT` (Right Shift, Enter). | |||
## Keycodes | |||
|Keycode |Description | | |||
|-----------|-------------------------------------------| | |||
|`KC_LSPO` |Left Shift when held, `(` when tapped | | |||
|`KC_RSPC` |Right Shift when held, `)` when tapped | | |||
|`KC_LCPO` |Left Control when held, `(` when tapped | | |||
|`KC_RCPC` |Right Control when held, `)` when tapped | | |||
|`KC_LAPO` |Left Alt when held, `(` when tapped | | |||
|`KC_RAPC` |Right Alt when held, `)` when tapped | | |||
|`KC_SFTENT`|Right Shift when held, `Enter` when tapped | | |||
## Caveats | |||
Space Cadet's functionality can conflict with the default Command functionality when both Shift keys are held at the same time. See the [Command feature](feature_command.md) for info on how to change it, or make sure that Command is disabled in your `rules.mk` with: | |||
```make | |||
COMMAND_ENABLE = no | |||
``` | |||
## Configuration | |||
By default Space Cadet assumes a US ANSI layout, but if your layout uses different keys for parentheses, you can redefine them in your `config.h`. In addition, you can redefine the modifier to send on tap, or even send no modifier at all. The new configuration defines bundle all options up into a single define of 3 key codes in this order: the `Modifier` when held or when used with other keys, the `Tap Modifer` sent when tapped (no modifier if `KC_TRNS`), finally the `Keycode` sent when tapped. Now keep in mind, mods from other keys will still apply to the `Keycode` if say `KC_RSFT` is held while tapping `KC_LSPO` key with `KC_TRNS` as the `Tap Modifer`. | |||
|Define |Default |Description | | |||
|----------------|-------------------------------|---------------------------------------------------------------------------------| | |||
|`LSPO_KEYS` |`KC_LSFT, LSPO_MOD, LSPO_KEY` |Send `KC_LSFT` when held, the mod and key defined by `LSPO_MOD` and `LSPO_KEY`. | | |||
|`RSPC_KEYS` |`KC_RSFT, RSPC_MOD, RSPC_KEY` |Send `KC_RSFT` when held, the mod and key defined by `RSPC_MOD` and `RSPC_KEY`. | | |||
|`LCPO_KEYS` |`KC_LCTL, KC_LCTL, KC_9` |Send `KC_LCTL` when held, the mod `KC_LCTL` with the key `KC_9` when tapped. | | |||
|`RCPO_KEYS` |`KC_RCTL, KC_RCTL, KC_0` |Send `KC_RCTL` when held, the mod `KC_RCTL` with the key `KC_0` when tapped. | | |||
|`LAPO_KEYS` |`KC_LALT, KC_LALT, KC_9` |Send `KC_LALT` when held, the mod `KC_LALT` with the key `KC_9` when tapped. | | |||
|`RAPO_KEYS` |`KC_RALT, KC_RALT, KC_0` |Send `KC_RALT` when held, the mod `KC_RALT` with the key `KC_0` when tapped. | | |||
|`SFTENT_KEYS` |`KC_RSFT, KC_TRNS, SFTENT_KEY` |Send `KC_RSFT` when held, no mod with the key `SFTENT_KEY` when tapped. | | |||
## Obsolete Configuration | |||
These defines are used in the above defines internally to support backwards compatibility, so you may continue to use them, however the above defines open up a larger range of flexibility than before. As an example, say you want to not send any modifier when you tap just `KC_LSPO`, with the old defines you had an all or nothing choice of using the `DISABLE_SPACE_CADET_MODIFIER` define. Now you can define that key as: `#define KC_LSPO_KEYS KC_LSFT, KC_TRNS, KC_9`. This tells the system to set Left Shift if held or used with other keys, then on tap send no modifier (transparent) with the `KC_9` | |||
|Define |Default |Description | | |||
|------------------------------|-------------|------------------------------------------------------------------| | |||
|`LSPO_KEY` |`KC_9` |The keycode to send when Left Shift is tapped | | |||
|`RSPC_KEY` |`KC_0` |The keycode to send when Right Shift is tapped | | |||
|`LSPO_MOD` |`KC_LSFT` |The modifier to apply to `LSPO_KEY` | | |||
|`RSPC_MOD` |`KC_RSFT` |The modifier to apply to `RSPC_KEY` | | |||
|`SFTENT_KEY` |`KC_ENT` |The keycode to send when the Shift key is tapped | | |||
|`DISABLE_SPACE_CADET_MODIFIER`|*Not defined*|If defined, prevent the Space Cadet from applying a modifier | |
@ -1,37 +0,0 @@ | |||
# Space Cadet Shift: The Future, Built In | |||
Steve Losh described the [Space Cadet Shift](http://stevelosh.com/blog/2012/10/a-modern-space-cadet/) quite well. Essentially, when you tap Left Shift on its own, you get an opening parenthesis; tap Right Shift on its own and you get the closing one. When held, the Shift keys function as normal. Yes, it's as cool as it sounds. | |||
## Usage | |||
Replace the Left Shift key in your keymap with `KC_LSPO` (Left Shift, Parenthesis Open), and Right Shift with `KC_RSPC` (Right Shift, Parenthesis Close). | |||
## Keycodes | |||
|Keycode |Description | | |||
|---------|--------------------------------------| | |||
|`KC_LSPO`|Left Shift when held, `(` when tapped | | |||
|`KC_RSPC`|Right Shift when held, `)` when tapped| | |||
## Caveats | |||
Space Cadet's functionality can conflict with the default Command functionality when both Shift keys are held at the same time. Make sure that Command is disabled in your `rules.mk` with: | |||
```make | |||
COMMAND_ENABLE = no | |||
``` | |||
## Configuration | |||
By default Space Cadet assumes a US ANSI layout, but if your layout uses different keys for parentheses, you can redefine them in your `config.h`. | |||
You can also disable the rollover, allowing you to use the opposite Shift key to cancel the Space Cadet state in the event of an erroneous press, instead of emitting a pair of parentheses when the keys are released. | |||
Also, by default, the Space Cadet applies modifiers LSPO_MOD and RSPC_MOD to keys defined by LSPO_KEY and RSPC_KEY. You can override this behavior by redefining those variables in your `config.h`. You can also prevent the Space Cadet to apply a modifier by defining DISABLE_SPACE_CADET_MODIFIER in your `config.h`. | |||
|Define |Default |Description | | |||
|------------------------------|-------------|--------------------------------------------------------------------------------| | |||
|`LSPO_KEY` |`KC_9` |The keycode to send when Left Shift is tapped | | |||
|`RSPC_KEY` |`KC_0` |The keycode to send when Right Shift is tapped | | |||
|`LSPO_MOD` |`KC_LSFT` |The keycode to send when Left Shift is tapped | | |||
|`RSPC_MOD` |`KC_RSFT` |The keycode to send when Right Shift is tapped | | |||
|`DISABLE_SPACE_CADET_ROLLOVER`|*Not defined*|If defined, use the opposite Shift key to cancel Space Cadet | | |||
|`DISABLE_SPACE_CADET_MODIFIER`|*Not defined*|If defined, prevent the Space Cadet to apply a modifier to LSPO_KEY and RSPC_KEY| |
@ -1,31 +0,0 @@ | |||
# Space Cadet Shift Enter | |||
Based on the [Space Cadet Shift](feature_space_cadet_shift.md) feature. Tap the Shift key on its own, and it behaves like Enter. When held, the Shift functions as normal. | |||
## Usage | |||
Replace any Shift key in your keymap with `KC_SFTENT` (Shift, Enter), and you're done. | |||
## Keycodes | |||
|Keycode |Description | | |||
|-----------|----------------------------------------| | |||
|`KC_SFTENT`|Right Shift when held, Enter when tapped| | |||
## Caveats | |||
As with Space Cadet Shift, this feature may conflict with Command, so it should be disabled in your `rules.mk` with: | |||
```make | |||
COMMAND_ENABLE = no | |||
``` | |||
This feature also uses the same timers as Space Cadet Shift, so using them in tandem may produce strange results. | |||
## Configuration | |||
By default Space Cadet assumes a US ANSI layout, but if you'd like to use a different key for Enter, you can redefine it in your `config.h`: | |||
|Define |Default |Description | | |||
|------------|--------|------------------------------------------------| | |||
|`SFTENT_KEY`|`KC_ENT`|The keycode to send when the Shift key is tapped| |
@ -0,0 +1,19 @@ | |||
#include "adkb96.h" | |||
#ifdef SWAP_HANDS_ENABLE | |||
__attribute__ ((weak)) | |||
const keypos_t hand_swap_config[MATRIX_ROWS][MATRIX_COLS] = { | |||
{{0, 6}, {1, 6}, {2, 6}, {3, 6}, {4, 6}, {5, 6}, {6, 6}, {7, 6}}, | |||
{{0, 7}, {1, 7}, {2, 7}, {3, 7}, {4, 7}, {5, 7}, {6, 7}, {7, 7}}, | |||
{{0, 8}, {1, 8}, {2, 8}, {3, 8}, {4, 8}, {5, 8}, {6, 8}, {7, 8}}, | |||
{{0, 9}, {1, 9}, {2, 9}, {3, 9}, {4, 9}, {5, 9}, {6, 9}, {7, 9}}, | |||
{{0,10}, {1,10}, {2,10}, {3,10}, {4,10}, {5,10}, {6,10}, {7,10}}, | |||
{{0,11}, {1,11}, {2,11}, {3,11}, {4,11}, {5,11}, {6,11}, {7,11}}, | |||
{{0, 0}, {1, 0}, {2, 0}, {3, 0}, {4, 0}, {5, 0}, {6, 0}, {7, 0}}, | |||
{{0, 1}, {1, 1}, {2, 1}, {3, 1}, {4, 1}, {5, 1}, {6, 1}, {7, 1}}, | |||
{{0, 2}, {1, 2}, {2, 2}, {3, 2}, {4, 2}, {5, 2}, {6, 2}, {7, 2}}, | |||
{{0, 3}, {1, 3}, {2, 3}, {3, 3}, {4, 3}, {5, 3}, {6, 3}, {7, 3}}, | |||
{{0, 4}, {1, 4}, {2, 4}, {3, 4}, {4, 4}, {5, 4}, {6, 4}, {7, 4}}, | |||
{{0, 5}, {1, 5}, {2, 5}, {3, 5}, {4, 5}, {5, 5}, {6, 5}, {7, 5}} | |||
}; | |||
#endif |
@ -0,0 +1,28 @@ | |||
#pragma once | |||
#include "quantum.h" | |||
#ifdef KEYBOARD_adkb96_rev1 | |||
#include "rev1.h" | |||
#endif | |||
// Used to create a keymap using only KC_ prefixed keys | |||
#define LAYOUT_kc_ortho_6x16( \ | |||
L00, L01, L02, L03, L04, L05, L06, L07, R00, R01, R02, R03, R04, R05, R06, R07, \ | |||
L10, L11, L12, L13, L14, L15, L16, L17, R10, R11, R12, R13, R14, R15, R16, R17, \ | |||
L20, L21, L22, L23, L24, L25, L26, L27, R20, R21, R22, R23, R24, R25, R26, R27, \ | |||
L30, L31, L32, L33, L34, L35, L36, L37, R30, R31, R32, R33, R34, R35, R36, R37, \ | |||
L40, L41, L42, L43, L44, L45, L46, L47, R40, R41, R42, R43, R44, R45, R46, R47, \ | |||
L50, L51, L52, L53, L54, L55, L56, L57, R50, R51, R52, R53, R54, R55, R56, R57 \ | |||
) \ | |||
LAYOUT( \ | |||
KC_##L00, KC_##L01, KC_##L02, KC_##L03, KC_##L04, KC_##L05, KC_##L06, KC_##L07, KC_##R00, KC_##R01, KC_##R02, KC_##R03, KC_##R04, KC_##R05, KC_##R06, KC_##R07, \ | |||
KC_##L10, KC_##L11, KC_##L12, KC_##L13, KC_##L14, KC_##L15, KC_##L16, KC_##L17, KC_##R10, KC_##R11, KC_##R12, KC_##R13, KC_##R14, KC_##R15, KC_##R16, KC_##R17, \ | |||
KC_##L20, KC_##L21, KC_##L22, KC_##L23, KC_##L24, KC_##L25, KC_##L26, KC_##L27, KC_##R20, KC_##R21, KC_##R22, KC_##R23, KC_##R24, KC_##R25, KC_##R26, KC_##R27, \ | |||
KC_##L30, KC_##L31, KC_##L32, KC_##L33, KC_##L34, KC_##L35, KC_##L36, KC_##L37, KC_##R30, KC_##R31, KC_##R32, KC_##R33, KC_##R34, KC_##R35, KC_##R36, KC_##R37, \ | |||
KC_##L40, KC_##L41, KC_##L42, KC_##L43, KC_##L44, KC_##L45, KC_##L46, KC_##L47, KC_##R40, KC_##R41, KC_##R42, KC_##R43, KC_##R44, KC_##R45, KC_##R46, KC_##R47, \ | |||
KC_##L50, KC_##L51, KC_##L52, KC_##L53, KC_##L54, KC_##L55, KC_##L56, KC_##L57, KC_##R50, KC_##R51, KC_##R52, KC_##R53, KC_##R54, KC_##R55, KC_##R56 ,KC_##R57 \ | |||
) | |||
#define LAYOUT_kc LAYOUT_kc_ortho_6x16 |
@ -0,0 +1,22 @@ | |||
/* | |||
Copyright 2012 Jun Wako <wakojun@gmail.com> | |||
Copyright 2015 Jack Humbert | |||
This program is free software: you can redistribute it and/or modify | |||
it under the terms of the GNU General Public License as published by | |||
the Free Software Foundation, either version 2 of the License, or | |||
(at your option) any later version. | |||
This program is distributed in the hope that it will be useful, | |||
but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |||
GNU General Public License for more details. | |||
You should have received a copy of the GNU General Public License | |||
along with this program. If not, see <http://www.gnu.org/licenses/>. | |||
*/ | |||
#pragma once | |||
#include "config_common.h" | |||
@ -0,0 +1,494 @@ | |||
{ | |||
"keyboard_name": "adkb96", | |||
"url": "", | |||
"maintainer": "qmk", | |||
"width": 16, | |||
"height": 6, | |||
"layouts": { | |||
"LAYOUT_ortho_6x16": { | |||
"key_count": 96, | |||
"layout": [ | |||
{ | |||
"label": "L00", | |||
"x": 0, | |||
"y": 0 | |||
}, | |||
{ | |||
"label": "L01", | |||
"x": 1, | |||
"y": 0 | |||
}, | |||
{ | |||
"label": "L02", | |||
"x": 2, | |||
"y": 0 | |||
}, | |||
{ | |||
"label": "L03", | |||
"x": 3, | |||
"y": 0 | |||
}, | |||
{ | |||
"label": "L04", | |||
"x": 4, | |||
"y": 0 | |||
}, | |||
{ | |||
"label": "L05", | |||
"x": 5, | |||
"y": 0 | |||
}, | |||
{ | |||
"label": "L06", | |||
"x": 6, | |||
"y": 0 | |||
}, | |||
{ | |||
"label": "L07", | |||
"x": 7, | |||
"y": 0 | |||
}, | |||
{ | |||
"label": "R00", | |||
"x": 8, | |||
"y": 0 | |||
}, | |||
{ | |||
"label": "R01", | |||
"x": 9, | |||
"y": 0 | |||
}, | |||
{ | |||
"label": "R02", | |||
"x": 10, | |||
"y": 0 | |||
}, | |||
{ | |||
"label": "R03", | |||
"x": 11, | |||
"y": 0 | |||
}, | |||
{ | |||
"label": "R04", | |||
"x": 12, | |||
"y": 0 | |||
}, | |||
{ | |||
"label": "R05", | |||
"x": 13, | |||
"y": 0 | |||
}, | |||
{ | |||
"label": "R06", | |||
"x": 14, | |||
"y": 0 | |||
}, | |||
{ | |||
"label": "R07", | |||
"x": 15, | |||
"y": 0 | |||
}, | |||
{ | |||
"label": "L10", | |||
"x": 0, | |||
"y": 1 | |||
}, | |||
{ | |||
"label": "L11", | |||
"x": 1, | |||
"y": 1 | |||
}, | |||
{ | |||
"label": "L12", | |||
"x": 2, | |||
"y": 1 | |||
}, | |||
{ | |||
"label": "L13", | |||
"x": 3, | |||
"y": 1 | |||
}, | |||
{ | |||
"label": "L14", | |||
"x": 4, | |||
"y": 1 | |||
}, | |||
{ | |||
"label": "L15", | |||
"x": 5, | |||
"y": 1 | |||
}, | |||
{ | |||
"label": "L16", | |||
"x": 6, | |||
"y": 1 | |||
}, | |||
{ | |||
"label": "L17", | |||
"x": 7, | |||
"y": 1 | |||
}, | |||
{ | |||
"label": "R10", | |||
"x": 8, | |||
"y": 1 | |||
}, | |||
{ | |||
"label": "R11", | |||
"x": 9, | |||
"y": 1 | |||
}, | |||
{ | |||
"label": "R12", | |||
"x": 10, | |||
"y": 1 | |||
}, | |||
{ | |||
"label": "R13", | |||
"x": 11, | |||
"y": 1 | |||
}, | |||
{ | |||
"label": "R14", | |||
"x": 12, | |||
"y": 1 | |||
}, | |||
{ | |||
"label": "R15", | |||
"x": 13, | |||
"y": 1 | |||
}, | |||
{ | |||
"label": "R16", | |||
"x": 14, | |||
"y": 1 | |||
}, | |||
{ | |||
"label": "R17", | |||
"x": 15, | |||
"y": 1 | |||
}, | |||
{ | |||
"label": "L20", | |||
"x": 0, | |||
"y": 2 | |||
}, | |||
{ | |||
"label": "L21", | |||
"x": 1, | |||
"y": 2 | |||
}, | |||
{ | |||
"label": "L22", | |||
"x": 2, | |||
"y": 2 | |||
}, | |||
{ | |||
"label": "L23", | |||
"x": 3, | |||
"y": 2 | |||
}, | |||
{ | |||
"label": "L24", | |||
"x": 4, | |||
"y": 2 | |||
}, | |||
{ | |||
"label": "L25", | |||
"x": 5, | |||
"y": 2 | |||
}, | |||
{ | |||
"label": "L26", | |||
"x": 6, | |||
"y": 2 | |||
}, | |||
{ | |||
"label": "L27", | |||
"x": 7, | |||
"y": 2 | |||
}, | |||
{ | |||
"label": "R20", | |||
"x": 8, | |||
"y": 2 | |||
}, | |||
{ | |||
"label": "R21", | |||
"x": 9, | |||
"y": 2 | |||
}, | |||
{ | |||
"label": "R22", | |||
"x": 10, | |||
"y": 2 | |||
}, | |||
{ | |||
"label": "R23", | |||
"x": 11, | |||
"y": 2 | |||
}, | |||
{ | |||
"label": "R24", | |||
"x": 12, | |||
"y": 2 | |||
}, | |||
{ | |||
"label": "R25", | |||
"x": 13, | |||
"y": 2 | |||
}, | |||
{ | |||
"label": "R26", | |||
"x": 14, | |||
"y": 2 | |||
}, | |||
{ | |||
"label": "R27", | |||
"x": 15, | |||
"y": 2 | |||
}, | |||
{ | |||
"label": "L30", | |||
"x": 0, | |||
"y": 3 | |||
}, | |||
{ | |||
"label": "L31", | |||
"x": 1, | |||
"y": 3 | |||
}, | |||
{ | |||
"label": "L32", | |||
"x": 2, | |||
"y": 3 | |||
}, | |||
{ | |||
"label": "L33", | |||
"x": 3, | |||
"y": 3 | |||
}, | |||
{ | |||
"label": "L34", | |||
"x": 4, | |||
"y": 3 | |||
}, | |||
{ | |||
"label": "L35", | |||
"x": 5, | |||
"y": 3 | |||
}, | |||
{ | |||
"label": "L36", | |||
"x": 6, | |||
"y": 3 | |||
}, | |||
{ | |||
"label": "L37", | |||
"x": 7, | |||
"y": 3 | |||
}, | |||
{ | |||
"label": "R30", | |||
"x": 8, | |||
"y": 3 | |||
}, | |||
{ | |||
"label": "R31", | |||
"x": 9, | |||
"y": 3 | |||
}, | |||
{ | |||
"label": "R32", | |||
"x": 10, | |||
"y": 3 | |||
}, | |||
{ | |||
"label": "R33", | |||
"x": 11, | |||
"y": 3 | |||
}, | |||
{ | |||
"label": "R34", | |||
"x": 12, | |||
"y": 3 | |||
}, | |||
{ | |||
"label": "R35", | |||
"x": 13, | |||
"y": 3 | |||
}, | |||
{ | |||
"label": "R36", | |||
"x": 14, | |||
"y": 3 | |||
}, | |||
{ | |||
"label": "R37", | |||
"x": 15, | |||
"y": 3 | |||
}, | |||
{ | |||
"label": "L40", | |||
"x": 0, | |||
"y": 4 | |||
}, | |||
{ | |||
"label": "L41", | |||
"x": 1, | |||
"y": 4 | |||
}, | |||
{ | |||
"label": "L42", | |||
"x": 2, | |||
"y": 4 | |||
}, | |||
{ | |||
"label": "L43", | |||
"x": 3, | |||
"y": 4 | |||
}, | |||
{ | |||
"label": "L44", | |||
"x": 4, | |||
"y": 4 | |||
}, | |||
{ | |||
"label": "L45", | |||
"x": 5, | |||
"y": 4 | |||
}, | |||
{ | |||
"label": "L46", | |||
"x": 6, | |||
"y": 4 | |||
}, | |||
{ | |||
"label": "L47", | |||
"x": 7, | |||
"y": 4 | |||
}, | |||
{ | |||
"label": "R40", | |||
"x": 8, | |||
"y": 4 | |||
}, | |||
{ | |||
"label": "R41", | |||
"x": 9, | |||
"y": 4 | |||
}, | |||
{ | |||
"label": "R42", | |||
"x": 10, | |||
"y": 4 | |||
}, | |||
{ | |||
"label": "R43", | |||
"x": 11, | |||
"y": 4 | |||
}, | |||
{ | |||
"label": "R44", | |||
"x": 12, | |||
"y": 4 | |||
}, | |||
{ | |||
"label": "R45", | |||
"x": 13, | |||
"y": 4 | |||
}, | |||
{ | |||
"label": "R46", | |||
"x": 14, | |||
"y": 4 | |||
}, | |||
{ | |||
"label": "R47", | |||
"x": 15, | |||
"y": 4 | |||
}, | |||
{ | |||
"label": "L50", | |||
"x": 0, | |||
"y": 5 | |||
}, | |||
{ | |||
"label": "L51", | |||
"x": 1, | |||
"y": 5 | |||
}, | |||
{ | |||
"label": "L52", | |||
"x": 2, | |||
"y": 5 | |||
}, | |||
{ | |||
"label": "L53", | |||
"x": 3, | |||
"y": 5 | |||
}, | |||
{ | |||
"label": "L54", | |||
"x": 4, | |||
"y": 5 | |||
}, | |||
{ | |||
"label": "L55", | |||
"x": 5, | |||
"y": 5 | |||
}, | |||
{ | |||
"label": "L56", | |||
"x": 6, | |||
"y": 5 | |||
}, | |||
{ | |||
"label": "L57", | |||
"x": 7, | |||
"y": 5 | |||
}, | |||
{ | |||
"label": "R50", | |||
"x": 8, | |||
"y": 5 | |||
}, | |||
{ | |||
"label": "R51", | |||
"x": 9, | |||
"y": 5 | |||
}, | |||
{ | |||
"label": "R52", | |||
"x": 10, | |||
"y": 5 | |||
}, | |||
{ | |||
"label": "R53", | |||
"x": 11, | |||
"y": 5 | |||
}, | |||
{ | |||
"label": "R54", | |||
"x": 12, | |||
"y": 5 | |||
}, | |||
{ | |||
"label": "R55", | |||
"x": 13, | |||
"y": 5 | |||
}, | |||
{ | |||
"label": "R56", | |||
"x": 14, | |||
"y": 5 | |||
}, | |||
{ | |||
"label": "R57", | |||
"x": 15, | |||
"y": 5 | |||
} | |||
] | |||
} | |||
} | |||
} |
@ -0,0 +1,34 @@ | |||
/* | |||
This is the c configuration file for the keymap | |||
Copyright 2012 Jun Wako <wakojun@gmail.com> | |||
Copyright 2015 Jack Humbert | |||
This program is free software: you can redistribute it and/or modify | |||
it under the terms of the GNU General Public License as published by | |||
the Free Software Foundation, either version 2 of the License, or | |||
(at your option) any later version. | |||
This program is distributed in the hope that it will be useful, | |||
but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |||
GNU General Public License for more details. | |||
You should have received a copy of the GNU General Public License | |||
along with this program. If not, see <http://www.gnu.org/licenses/>. | |||
*/ | |||
#pragma once | |||
/* Use I2C or Serial, not both */ | |||
#define USE_SERIAL | |||
//#define USE_I2C | |||
/* Select hand configuration */ | |||
#define MASTER_LEFT | |||
// #define MASTER_RIGHT | |||
// #define EE_HANDS | |||
#define FORCE_NKRO |
@ -0,0 +1,15 @@ | |||
#include QMK_KEYBOARD_H | |||
extern keymap_config_t keymap_config; | |||
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
[0] = LAYOUT( | |||
KC_ESC, XXXXXXX,KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, KC_INS, KC_DELT, | |||
KC_ZKHK,KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_MINS,KC_EQL, KC_JYEN,KC_BSPC,KC_BSPC, | |||
KC_TAB, KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_LBRC,KC_RBRC,KC_ENT, KC_ENT, | |||
KC_CAPS,KC_CAPS,KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN,KC_QUOT,KC_BSLS,KC_ENT, KC_ENT, | |||
KC_LSFT,KC_LSFT,KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM,KC_DOT, KC_SLSH,KC_RO, KC_UP, KC_RSFT,KC_RSFT, | |||
KC_LCTL,KC_LALT,KC_LGUI,KC_MHEN,KC_SPC, KC_SPC, KC_SPC, KC_SPC, KC_HENK,KC_KANA,KC_RALT,KC_RCTL,KC_LEFT,KC_DOWN,KC_RGHT,XXXXXXX | |||
) | |||
}; |
@ -0,0 +1,17 @@ | |||
# ADKB96 | |||
![ADKB96](http://btoshop.jp/wp-content/uploads/sites/3/2019/04/ADKB96_ALL.png) | |||
A 16x6 ortholinear keyboard kit made and sold by Bit Trade One Ltd. [More info on Web](http://bit-trade-one.co.jp/selfmadekb/adkb96/) | |||
Keyboard Maintainer: [Bit Trade One Ltd.](http://bit-trade-one.co.jp/) | |||
Hardware Supported: ADKB96 PCB, Pro Micro | |||
Hardware Availability: [PCB & case Data](https://github.com/bit-trade-one/ADKB96-hardware), [BTOS Shop](http://btoshop.jp/2019/04/11/4562469772424/) | |||
Make example for this keyboard (after setting up your build environment): | |||
```sh | |||
make adkb96/rev1:default | |||
``` | |||
See the [build environment setup](https://docs.qmk.fm/#/getting_started_build_tools) and the [make instructions](https://docs.qmk.fm/#/getting_started_make_guide) for more information. Brand new to QMK? Start with our [Complete Newbs Guide](https://docs.qmk.fm/#/newbs). |
@ -0,0 +1,78 @@ | |||
/* | |||
Copyright 2012 Jun Wako <wakojun@gmail.com> | |||
Copyright 2015 Jack Humbert | |||
This program is free software: you can redistribute it and/or modify | |||
it under the terms of the GNU General Public License as published by | |||
the Free Software Foundation, either version 2 of the License, or | |||
(at your option) any later version. | |||
This program is distributed in the hope that it will be useful, | |||
but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |||
GNU General Public License for more details. | |||
You should have received a copy of the GNU General Public License | |||
along with this program. If not, see <http://www.gnu.org/licenses/>. | |||
*/ | |||
/* USB Device descriptor parameter */ | |||
#define VENDOR_ID 0x00a5 | |||
#define PRODUCT_ID 0xad96 | |||
#define DEVICE_VER 0x0001 | |||
#define MANUFACTURER Bit Trade One | |||
#define PRODUCT ADKB96 | |||
#define DESCRIPTION | |||
/* key matrix size */ | |||
// Rows are doubled-up | |||
#define MATRIX_ROWS 12 | |||
#define MATRIX_COLS 8 | |||
// wiring of each half | |||
#define MATRIX_ROW_PINS { D4, C6, D7, E6, B4, B5 } | |||
#define MATRIX_COL_PINS { B6, B2, B3, B1, F7, F6, F5, F4 } | |||
#define SOFT_SERIAL_PIN D0 | |||
/* define tapping term */ | |||
#define TAPPING_TERM 100 | |||
/* define if matrix has ghost */ | |||
//#define MATRIX_HAS_GHOST | |||
/* number of backlight levels */ | |||
// #define BACKLIGHT_LEVELS 3 | |||
/* Set 0 if debouncing isn't needed */ | |||
#define DEBOUNCING_DELAY 5 | |||
/* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */ | |||
#define LOCKING_SUPPORT_ENABLE | |||
/* Locking resynchronize hack */ | |||
#define LOCKING_RESYNC_ENABLE | |||
/* ws2812 RGB LED */ | |||
/* | |||
#define RGB_DI_PIN D3 | |||
#define RGBLED_NUM 12 // Number of LEDs | |||
*/ | |||
/* | |||
* Feature disable options | |||
* These options are also useful to firmware size reduction. | |||
*/ | |||
/* disable debug print */ | |||
// #define NO_DEBUG | |||
/* disable print */ | |||
// #define NO_PRINT | |||
/* disable action features */ | |||
//#define NO_ACTION_LAYER | |||
//#define NO_ACTION_TAPPING | |||
//#define NO_ACTION_ONESHOT | |||
//#define NO_ACTION_MACRO | |||
//#define NO_ACTION_FUNCTION | |||
@ -0,0 +1,15 @@ | |||
#include "adkb96.h" | |||
void matrix_init_kb(void) { | |||
// // green led on | |||
// DDRD |= (1<<5); | |||
// PORTD &= ~(1<<5); | |||
// // orange led on | |||
// DDRB |= (1<<0); | |||
// PORTB &= ~(1<<0); | |||
matrix_init_user(); | |||
}; | |||
@ -0,0 +1,44 @@ | |||
#pragma once | |||
#include "adkb96.h" | |||
//void promicro_bootloader_jmp(bool program); | |||
#ifdef USE_I2C | |||
#include <stddef.h> | |||
#ifdef __AVR__ | |||
#include <avr/io.h> | |||
#include <avr/interrupt.h> | |||
#endif | |||
#endif | |||
//void promicro_bootloader_jmp(bool program); | |||
// Keymap with right side flipped | |||
// (TRRS jack on both halves are to the right) | |||
#define LAYOUT_ortho_6x16( \ | |||
L00, L01, L02, L03, L04, L05, L06, L07, R00, R01, R02, R03, R04, R05, R06, R07, \ | |||
L10, L11, L12, L13, L14, L15, L16, L17, R10, R11, R12, R13, R14, R15, R16, R17, \ | |||
L20, L21, L22, L23, L24, L25, L26, L27, R20, R21, R22, R23, R24, R25, R26, R27, \ | |||
L30, L31, L32, L33, L34, L35, L36, L37, R30, R31, R32, R33, R34, R35, R36, R37, \ | |||
L40, L41, L42, L43, L44, L45, L46, L47, R40, R41, R42, R43, R44, R45, R46, R47, \ | |||
L50, L51, L52, L53, L54, L55, L56, L57, R50, R51, R52, R53, R54, R55, R56, R57 \ | |||
) \ | |||
{ \ | |||
{ L00, L01, L02, L03, L04, L05, L06, L07 }, \ | |||
{ L10, L11, L12, L13, L14, L15, L16, L17 }, \ | |||
{ L20, L21, L22, L23, L24, L25, L26, L27 }, \ | |||
{ L30, L31, L32, L33, L34, L35, L36, L37 }, \ | |||
{ L40, L41, L42, L43, L44, L45, L46, L47 }, \ | |||
{ L50, L51, L52, L53, L54, L55, L56, L57 }, \ | |||
{ R00, R01, R02, R03, R04, R05, R06, R07 }, \ | |||
{ R10, R11, R12, R13, R14, R15, R16, R17 }, \ | |||
{ R20, R21, R22, R23, R24, R25, R26, R27 }, \ | |||
{ R30, R31, R32, R33, R34, R35, R36, R37 }, \ | |||
{ R40, R41, R42, R43, R44, R45, R46, R47 }, \ | |||
{ R50, R51, R52, R53, R54, R55, R56, R57 } \ | |||
} | |||
#define LAYOUT LAYOUT_ortho_6x16 | |||
@ -0,0 +1,15 @@ | |||
#pragma once | |||
#include "quantum.h" | |||
#define LAYOUT_ortho_4x4( \ | |||
K00, K01, K02, K03, \ | |||
K10, K11, K12, K13, \ | |||
K20, K21, K22, K23, \ | |||
K30, K31, K32, K33 \ | |||
) { \ | |||
{ K00, K01, K02, K03 }, \ | |||
{ K10, K11, K12, K13 }, \ | |||
{ K20, K21, K22, K23 }, \ | |||
{ K30, K31, K32, K33 } \ | |||
} |
@ -0,0 +1,46 @@ | |||
#pragma once | |||
#include "config_common.h" | |||
/* USB Device descriptor parameter */ | |||
#define VENDOR_ID 0xFEED | |||
#define PRODUCT_ID 0x6060 | |||
#define DEVICE_VER 0x0001 | |||
#define MANUFACTURER KPrepublic | |||
#define PRODUCT bm16s | |||
#define DESCRIPTION KPrepublic bm16s | |||
/* key matrix size */ | |||
#define MATRIX_ROWS 4 | |||
#define MATRIX_COLS 4 | |||
/* key matrix pins */ | |||
#define MATRIX_ROW_PINS { D1, D0, D3, D2 } | |||
#define MATRIX_COL_PINS { F7, F6, D4, D6 } | |||
#define UNUSED_PINS | |||
/* COL2ROW or ROW2COL */ | |||
#define DIODE_DIRECTION COL2ROW | |||
/* number of backlight levels */ | |||
#ifdef BACKLIGHT_PIN | |||
#define BACKLIGHT_LEVELS 3 | |||
#endif | |||
/* Set 0 if debouncing isn't needed */ | |||
#define DEBOUNCING_DELAY 5 | |||
/* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */ | |||
#define LOCKING_SUPPORT_ENABLE | |||
/* Locking resynchronize hack */ | |||
#define LOCKING_RESYNC_ENABLE | |||
#define RGB_DI_PIN E2 | |||
#ifdef RGB_DI_PIN | |||
#define RGBLIGHT_ANIMATIONS | |||
#define RGBLED_NUM 16 | |||
#define RGBLIGHT_HUE_STEP 8 | |||
#define RGBLIGHT_SAT_STEP 8 | |||
#define RGBLIGHT_VAL_STEP 8 | |||
#endif |
@ -0,0 +1,30 @@ | |||
{ | |||
"keyboard_name": "bm16s", | |||
"url": "", | |||
"maintainer": "qmk", | |||
"width": 4, | |||
"height": 4, | |||
"layouts": { | |||
"LAYOUT_ortho_4x4": { | |||
"key_count": 16, | |||
"layout": [ | |||
{"x":0, "y":0}, | |||
{"x":1, "y":0}, | |||
{"x":2, "y":0}, | |||
{"x":3, "y":0}, | |||
{"x":0, "y":1}, | |||
{"x":1, "y":1}, | |||
{"x":2, "y":1}, | |||
{"x":3, "y":1}, | |||
{"x":0, "y":2}, | |||
{"x":1, "y":2}, | |||
{"x":2, "y":2}, | |||
{"x":3, "y":2}, | |||
{"x":0, "y":3}, | |||
{"x":1, "y":3}, | |||
{"x":2, "y":3}, | |||
{"x":3, "y":3} | |||
] | |||
} | |||
} | |||
} |
@ -0,0 +1,16 @@ | |||
#include QMK_KEYBOARD_H | |||
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
[0] = LAYOUT_ortho_4x4( | |||
KC_KP_7, KC_KP_8, KC_KP_9, MO(1), \ | |||
KC_KP_4, KC_KP_5, KC_KP_6, KC_PMNS, \ | |||
KC_KP_1, KC_KP_2, KC_KP_3, KC_PPLS, \ | |||
KC_KP_0, KC_PDOT, KC_PCMM, KC_PENT \ | |||
), | |||
[1] = LAYOUT_ortho_4x4( | |||
RESET, BL_STEP, _______, KC_VOLU, \ | |||
BL_TOGG, BL_DEC, BL_INC, KC_VOLD, \ | |||
RGB_TOG, RGB_MOD, RGB_HUI, KC_MUTE, \ | |||
RGB_SAI, RGB_SAD, RGB_HUD, _______ \ | |||
), | |||
}; |
@ -0,0 +1,20 @@ | |||
#include QMK_KEYBOARD_H | |||
#define RGB_BRU RGB_VAI | |||
#define RGB_BRD RGB_VAD | |||
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
[0] = LAYOUT_ortho_4x4( | |||
KC_BRIU, _______, _______, KC_VOLU, \ | |||
KC_BRID, _______, _______, KC_VOLD, \ | |||
_______, _______, _______, KC_MUTE, \ | |||
KC_MPRV, KC_MPLY, KC_MNXT, MO(1) \ | |||
), | |||
[1] = LAYOUT_ortho_4x4( | |||
RESET, _______, _______, _______, \ | |||
RGB_SPD, RGB_BRU, RGB_SPI, _______, \ | |||
RGB_RMOD, RGB_BRD, RGB_MOD, _______, \ | |||
RGB_TOG, _______, _______, _______ \ | |||
), | |||
}; |
@ -0,0 +1,13 @@ | |||
# bm16s | |||
A 16-key macropad, with USB C and per-key RGB backlighting. This is a variant of the BM16A, but with low profile Choc switches. | |||
Keyboard Maintainer: QMK Community | |||
Hardware Supported: The PCBs, controllers supported | |||
Hardware Availability: [KPrepublic](https://kprepublic.com/collections/pcb/products/bm16s-16-keys-custom-mechanical-keyboard-pcb-plate-programmed-numpad-layouts-qmk-firmware-with-rgb-switch-leds-choc-switch); [AliExpress](https://www.aliexpress.com/item/bm16s-16-keys-Custom-Mechanical-Keyboard-PCB-plate-programmed-numpad-layouts-qmk-firmware-with-rgb-switch/32999247908.html); [Massdrop](https://www.massdrop.com/buy/78169) | |||
Make example for this keyboard (after setting up your build environment): | |||
make bm16s:default | |||
See the [build environment setup](https://docs.qmk.fm/#/getting_started_build_tools) and the [make instructions](https://docs.qmk.fm/#/getting_started_make_guide) for more information. Brand new to QMK? Start with our [Complete Newbs Guide](https://docs.qmk.fm/#/newbs). |
@ -0,0 +1,72 @@ | |||
# MCU name | |||
MCU = atmega32u4 | |||
# Processor frequency. | |||
# This will define a symbol, F_CPU, in all source code files equal to the | |||
# processor frequency in Hz. You can then use this symbol in your source code to | |||
# calculate timings. Do NOT tack on a 'UL' at the end, this will be done | |||
# automatically to create a 32-bit value in your source code. | |||
# | |||
# This will be an integer division of F_USB below, as it is sourced by | |||
# F_USB after it has run through any CPU prescalers. Note that this value | |||
# does not *change* the processor frequency - it should merely be updated to | |||
# reflect the processor speed set externally so that the code can use accurate | |||
# software delays. | |||
F_CPU = 16000000 | |||
# | |||
# LUFA specific | |||
# | |||
# Target architecture (see library "Board Types" documentation). | |||
ARCH = AVR8 | |||
# Input clock frequency. | |||
# This will define a symbol, F_USB, in all source code files equal to the | |||
# input clock frequency (before any prescaling is performed) in Hz. This value may | |||
# differ from F_CPU if prescaling is used on the latter, and is required as the | |||
# raw input clock is fed directly to the PLL sections of the AVR for high speed | |||
# clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL' | |||
# at the end, this will be done automatically to create a 32-bit value in your | |||
# source code. | |||
# | |||
# If no clock division is performed on the input clock inside the AVR (via the | |||
# CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU. | |||
F_USB = $(F_CPU) | |||
# Interrupt driven control endpoint task(+60) | |||
OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT | |||
# Bootloader selection | |||
# Teensy halfkay | |||
# Pro Micro caterina | |||
# Atmel DFU atmel-dfu | |||
# LUFA DFU lufa-dfu | |||
# QMK DFU qmk-dfu | |||
# atmega32a bootloadHID | |||
BOOTLOADER = atmel-dfu | |||
# If you don't know the bootloader type, then you can specify the | |||
# Boot Section Size in *bytes* by uncommenting out the OPT_DEFS line | |||
# Teensy halfKay 512 | |||
# Teensy++ halfKay 1024 | |||
# Atmel DFU loader 4096 | |||
# LUFA bootloader 4096 | |||
# USBaspLoader 2048 | |||
# OPT_DEFS += -DBOOTLOADER_SIZE=4096 | |||
# Build Options | |||
# comment out to disable the options. | |||
# | |||
BOOTMAGIC_ENABLE = lite # Virtual DIP switch configuration | |||
MOUSEKEY_ENABLE = yes # Mouse keys | |||
EXTRAKEY_ENABLE = yes # Audio control and System control | |||
CONSOLE_ENABLE = no # Console for debug | |||
COMMAND_ENABLE = no # Commands for debug and configuration | |||
SLEEP_LED_ENABLE = no # Breathing sleep LED during USB suspend | |||
NKRO_ENABLE = yes # USB Nkey Rollover - if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work | |||
BACKLIGHT_ENABLE = no # Enable keyboard backlight functionality | |||
AUDIO_ENABLE = no | |||
RGBLIGHT_ENABLE = yes | |||
LAYOUTS = ortho_4x4 |
@ -0,0 +1,56 @@ | |||
/* Copyright 2019 Jeremy Bernhardt | |||
* | |||
* This program is free software: you can redistribute it and/or modify | |||
* it under the terms of the GNU General Public License as published by | |||
* the Free Software Foundation, either version 2 of the License, or | |||
* (at your option) any later version. | |||
* | |||
* This program is distributed in the hope that it will be useful, | |||
* but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |||
* GNU General Public License for more details. | |||
* | |||
* You should have received a copy of the GNU General Public License | |||
* along with this program. If not, see <http://www.gnu.org/licenses/>. | |||
*/ | |||
#include "butterstick.h" | |||
// Optional override functions below. | |||
// You can leave any or all of these undefined. | |||
// These are only required if you want to perform custom actions. | |||
/* | |||
void matrix_init_kb(void) { | |||
// put your keyboard start-up code here | |||
// runs once when the firmware starts up | |||
matrix_init_user(); | |||
} | |||
*/ | |||
void matrix_scan_kb(void) { | |||
#ifdef DEBUG_MATRIX | |||
for (uint8_t c = 0; c < MATRIX_COLS; c++) | |||
for (uint8_t r = 0; r < MATRIX_ROWS; r++) | |||
if (matrix_is_on(r, c)) xprintf("r:%d c:%d \n", r, c); | |||
#endif | |||
matrix_scan_user(); | |||
} | |||
/* | |||
bool process_record_kb(uint16_t keycode, keyrecord_t *record) { | |||
// put your per-action keyboard code here | |||
// runs for every action, just before processing by the firmware | |||
return process_record_user(keycode, record); | |||
} | |||
void led_set_kb(uint8_t usb_led) { | |||
// put your keyboard LED indicator (ex: Caps Lock LED) toggling code here | |||
led_set_user(usb_led); | |||
} | |||
*/ |
@ -0,0 +1,11 @@ | |||
#pragma once | |||
#include "quantum.h" | |||
#define LAYOUT_butter( \ | |||
k09, k08, k07, k06, k05, k04, k03, k02, k01, k00, \ | |||
k19, k18, k17, k16, k15, k14, k13, k12, k11, k10 \ | |||
) { \ | |||
{ k00, k01, k02, k03, k04, k05, k06, k07, k08, k09}, \ | |||
{ k10, k11, k12, k13, k14, k15, k16, k17, k18, k19}, \ | |||
} |
@ -0,0 +1,26 @@ | |||
#pragma once | |||
#include "config_common.h" | |||
/* USB Device descriptor parameter */ | |||
#define VENDOR_ID 0xFEED | |||
#define PRODUCT_ID 0x1337 | |||
#define DEVICE_VER 0x0001 | |||
#define MANUFACTURER g Heavy Industries | |||
#define PRODUCT Butter Stick | |||
#define DESCRIPTION Its a stick of butter | |||
#define VERSION "Paula Deen" | |||
#define DEBOUNCING_DELAY 5 | |||
#define FORCE_NKRO | |||
/* key matrix size */ | |||
#define MATRIX_ROWS 2 | |||
#define MATRIX_COLS 10 | |||
#define MATRIX_ROW_PINS { F4, F5 } | |||
#define MATRIX_COL_PINS { B0, B1, B2, B3, B4, B5, B6, B7, C6, C7} | |||
#define UNUSED_PINS | |||
/* COL2ROW, ROW2COL*/ | |||
#define DIODE_DIRECTION ROW2COL | |||
@ -0,0 +1,183 @@ | |||
#include QMK_KEYBOARD_H | |||
#include "sten.h" | |||
/* | |||
* Key names are inherited from steno machines | |||
* .-----------------------------------------------------. | |||
* | LSU | LFT | LP | LH | ST1 | RF | RP | RL | RT | RD | | |||
* |-----------------------------------------------------| | |||
* | LSD | LK | LW | LR | ST2 | RR | RB | RG | RS | RZ | | |||
* '-----------------------------------------------------' | |||
*/ | |||
// Function prefixes | |||
#define MEDIA (LSD | LK | LW | LR) | |||
#define FUNCT (LSD | LK | LP | LH) | |||
#define MOVE (LSU | LFT | LP | LH) | |||
#define SYMB (RD | RZ) | |||
#define NUMA (LW | LR) | |||
#define NUMB (RR | RB) | |||
// QMK Layer Numbers | |||
#define BASE 0 | |||
#define GAME 1 | |||
// Do not change QMK Layer 0! This is your main keyboard. | |||
// Make your QMK modifications to the later layers, to add | |||
// keys/customize on the first layer modify processQwerty(): | |||
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
[BASE] = LAYOUT_butter( | |||
STN_S1, STN_TL, STN_PL, STN_HL, STN_ST1, STN_FR, STN_PR, STN_LR, STN_TR, STN_DR, | |||
STN_S2, STN_KL, STN_WL, STN_RL, STN_ST2, STN_RR, STN_BR, STN_GR, STN_SR, STN_ZR | |||
), | |||
// I don't game don't roast me thanks | |||
[GAME] = LAYOUT_butter( | |||
KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_ENT, | |||
KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, TO(BASE) | |||
) | |||
}; | |||
// Note: You can only use basic keycodes here! | |||
// P() is just a wrapper to make your life easier, any C code can be executed. | |||
// Only the longest matched chord is run! | |||
// | |||
// http://docs.gboards.ca | |||
uint32_t processQwerty(bool lookup) { | |||
// SECRET AGENT CHORDS | |||
P( LSU | LK | RS | RD, SEND_STRING(VERSION); SEND_STRING(__DATE__)); | |||
P( LSD | RZ, SEND(KC_SPC)); | |||
// Dual chords | |||
P( LP | LH, CLICK_MOUSE(KC_MS_BTN2)); | |||
P( ST1 | RF, CLICK_MOUSE(KC_MS_BTN1)); | |||
P( LSU | LFT, SEND(KC_ESC)); | |||
P( LSD | LK, SEND(KC_LSFT)); | |||
P( RZ | RS, SEND(KC_LSFT)); | |||
P( ST2 | RR, SEND(KC_SPC)); | |||
P( RP | RL, SEND(KC_LGUI)); | |||
P( RT | RD, SEND(KC_LCTL)); | |||
P( RL | RT, SEND(KC_LALT)); | |||
P( LSU | LSD | LFT | LK, SEND(KC_LCTL)); | |||
P( RS | RT | RD | RZ, SEND(KC_ENT)); | |||
// Function Layer | |||
P( FUNCT | RF, SEND(KC_F1)); | |||
P( FUNCT | RP, SEND(KC_F2)); | |||
P( FUNCT | RL, SEND(KC_F3)); | |||
P( FUNCT | RT, SEND(KC_F4)); | |||
P( FUNCT | RF | RR, SEND(KC_F5)); | |||
P( FUNCT | RP | RB, SEND(KC_F6)); | |||
P( FUNCT | RL | RG, SEND(KC_F7)); | |||
P( FUNCT | RT | RS, SEND(KC_F8)); | |||
P( FUNCT | RR, SEND(KC_F9)); | |||
P( FUNCT | RB, SEND(KC_F10)); | |||
P( FUNCT | RG, SEND(KC_F11)); | |||
P( FUNCT | RS, SEND(KC_F12)); | |||
// Movement Layer | |||
P( MOVE | RF, SEND(KC_LEFT)); | |||
P( MOVE | RP, SEND(KC_DOWN)); | |||
P( MOVE | RL, SEND(KC_UP)); | |||
P( MOVE | RT, SEND(KC_RIGHT)); | |||
P( MOVE | ST1, SEND(KC_PGUP)); | |||
P( MOVE | ST2, SEND(KC_PGDN)); | |||
// Media Layer | |||
P( MEDIA | RF, SEND(KC_MPRV)); | |||
P( MEDIA | RP, SEND(KC_MPLY)); | |||
P( MEDIA | RL, SEND(KC_MPLY)); | |||
P( MEDIA | RT, SEND(KC_MNXT)); | |||
P( MEDIA | RG, SEND(KC_VOLU)); | |||
P( MEDIA | RB, SEND(KC_VOLD)); | |||
P( MEDIA | RS, SEND(KC_MUTE)); | |||
// Number Row, Right | |||
P( NUMB | LSU, SEND(KC_1)); | |||
P( NUMB | LFT, SEND(KC_2)); | |||
P( NUMB | LP, SEND(KC_3)); | |||
P( NUMB | LH, SEND(KC_4)); | |||
P( NUMB | ST1, SEND(KC_5)); | |||
P( NUMB | RF, SEND(KC_6)); | |||
P( NUMB | RP, SEND(KC_7)); | |||
P( NUMB | RL, SEND(KC_8)); | |||
P( NUMB | RT, SEND(KC_9)); | |||
P( NUMB | RD, SEND(KC_0)); | |||
// Number Row, Left | |||
P( NUMA | LSU, SEND(KC_1)); | |||
P( NUMA | LFT, SEND(KC_2)); | |||
P( NUMA | LP, SEND(KC_3)); | |||
P( NUMA | LH, SEND(KC_4)); | |||
P( NUMA | ST1, SEND(KC_5)); | |||
P( NUMA | RF, SEND(KC_6)); | |||
P( NUMA | RP, SEND(KC_7)); | |||
P( NUMA | RL, SEND(KC_8)); | |||
P( NUMA | RT, SEND(KC_9)); | |||
P( NUMA | RD, SEND(KC_0)); | |||
// Symbols and Numbers | |||
P( SYMB | LP | LW, SEND(KC_LSFT); SEND(KC_9)); // ( | |||
P( SYMB | LH | LR, SEND(KC_LSFT); SEND(KC_0)); // ) | |||
P( SYMB | ST1 | ST2, SEND(KC_GRV)); // ` | |||
P( SYMB | RR | RF, SEND(KC_LSFT); SEND(KC_3)); // # | |||
P( SYMB | LFT | LK, SEND(KC_LSFT); SEND(KC_4)); // $ | |||
P( SYMB | LSU, SEND(KC_LSFT); SEND(KC_1)); // ! | |||
P( SYMB | LSD, SEND(KC_LSFT); SEND(KC_5)); // % | |||
P( SYMB | LFT, SEND(KC_LSFT); SEND(KC_2)); // @ | |||
P( SYMB | LK, SEND(KC_LSFT); SEND(KC_6)); // ^ | |||
P( SYMB | LP, SEND(KC_LSFT); SEND(KC_LBRC)); // { | |||
P( SYMB | LW, SEND(KC_LBRC)); | |||
P( SYMB | LH, SEND(KC_LSFT); SEND(KC_RBRC)); // } | |||
P( SYMB | LR, SEND(KC_RBRC)); | |||
P( SYMB | ST1, SEND(KC_LSFT); SEND(KC_BSLS)); // | | |||
P( SYMB | ST2, SEND(KC_LSFT); SEND(KC_GRV)); // ~ | |||
P( SYMB | RP | RB, SEND(KC_QUOT)); | |||
P( SYMB | RP | RG, SEND(KC_LSFT); SEND(KC_QUOT)); // " | |||
P( SYMB | RF, SEND(KC_KP_PLUS)); | |||
P( SYMB | RR, SEND(KC_LSFT); SEND(KC_7)); // & | |||
P( SYMB | RP, SEND(KC_MINS)); | |||
P( SYMB | RB, SEND(KC_EQL)); | |||
P( SYMB | RL, SEND(KC_SLSH)); | |||
P( SYMB | RG, SEND(KC_COMM)); | |||
P( SYMB | RT, SEND(KC_PAST)); | |||
P( SYMB | RS, SEND(KC_DOT)); | |||
// Letters | |||
P( LSU | LSD, SEND(KC_A)); | |||
P( LFT | LK, SEND(KC_S)); | |||
P( LP | LW, SEND(KC_D)); | |||
P( LH | LR, SEND(KC_F)); | |||
P( ST1 | ST2, SEND(KC_G)); | |||
P( RF | RR, SEND(KC_H)); | |||
P( RT | RS, SEND(KC_L)); | |||
P( RD | RZ, SEND(KC_SCLN)); | |||
P( RG | RL, SEND(KC_K)); | |||
P( RP | RB, SEND(KC_J)); | |||
P( LSU, SEND(KC_Q)); | |||
P( LSD, SEND(KC_Z)); | |||
P( LFT, SEND(KC_W)); | |||
P( LK, SEND(KC_X)); | |||
P( LP, SEND(KC_E)); | |||
P( LW, SEND(KC_C)); | |||
P( LH, SEND(KC_R)); | |||
P( LR, SEND(KC_V)); | |||
P( ST1, SEND(KC_T)); | |||
P( ST2, SEND(KC_B)); | |||
P( RF, SEND(KC_Y)); | |||
P( RR, SEND(KC_N)); | |||
P( RP, SEND(KC_U)); | |||
P( RB, SEND(KC_M)); | |||
P( RL, SEND(KC_I)); | |||
P( RG, SEND(KC_COMM)); | |||
P( RT, SEND(KC_O)); | |||
P( RS, SEND(KC_DOT)); | |||
P( RD, SEND(KC_P)); | |||
P( RZ, SEND(KC_SLSH)); | |||
return 0; | |||
} | |||
// Don't fuck with this, thanks. | |||
size_t keymapsCount = sizeof(keymaps)/sizeof(keymaps[0]); |
@ -0,0 +1,14 @@ | |||
# Butter Stick | |||
![Butter Stick](https://i.redd.it/mvteaomko7s21.jpg) | |||
A chorded 20% keyboard packing full sized useage into your pocket. More info on [gboards.ca](http://docs.gboards.ca/Meet-Butter-Stick)! | |||
Keyboard Maintainer: [Germ](https://github.com/germ) | |||
Hardware Availability: [g Heavy Industries](https://www.gboards.ca/product/butter-stick-limited-edition) | |||
Make example for this keyboard (after setting up your build environment): | |||
make butterstick:default | |||
See the [build environment setup](https://docs.qmk.fm/#/getting_started_build_tools) and the [make instructions](https://docs.qmk.fm/#/getting_started_make_guide) for more information. Brand new to QMK? Start with our [Complete Newbs Guide](https://docs.qmk.fm/#/newbs). |
@ -0,0 +1,19 @@ | |||
# MCU name | |||
MCU = atmega32u4 | |||
F_CPU = 16000000 | |||
ARCH = AVR8 | |||
F_USB = $(F_CPU) | |||
OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT -DONLYQWERTY -DDEBUG_MATRIX | |||
SRC += sten.c | |||
EXTRAFLAGS += -flto | |||
BOOTLOADER = atmel-dfu | |||
MOUSEKEY_ENABLE = yes # Mouse keys(+4700) | |||
EXTRAKEY_ENABLE = yes # Audio control and System control(+450) | |||
CONSOLE_ENABLE = yes # Console for debug(+400) | |||
COMMAND_ENABLE = no # Commands for debug and configuration | |||
NKRO_ENABLE = yes # USB Nkey Rollover | |||
STENO_ENABLE = yes # Needed for chording | |||
@ -0,0 +1,367 @@ | |||
#include "sten.h" | |||
// Chord state | |||
uint32_t cChord = 0; // Current Chord | |||
int chordIndex = 0; // Keys in previousachord | |||
int32_t chordState[32]; // Full Chord history | |||
#define QWERBUF 24 // Size of chords to buffer for output | |||
bool repeatFlag = false; // Should we repeat? | |||
uint32_t pChord = 0; // Previous Chord | |||
int pChordIndex = 0; // Keys in previousachord | |||
uint32_t pChordState[32]; // Previous chord sate | |||
uint32_t stickyBits = 0; // Or'd with every incoming press | |||
// Mode state | |||
enum MODE { STENO = 0, QWERTY, COMMAND }; | |||
enum MODE pMode; | |||
bool QWERSTENO = false; | |||
#ifdef ONLYQWERTY | |||
enum MODE cMode = QWERTY; | |||
#else | |||
enum MODE cMode = STENO; | |||
#endif | |||
// Command State | |||
#define MAX_CMD_BUF 20 | |||
uint8_t CMDLEN = 0; | |||
uint8_t CMDBUF[MAX_CMD_BUF]; | |||
// Key Repeat state | |||
bool inChord = false; | |||
bool repEngaged = false; | |||
uint16_t repTimer = 0; | |||
#define REP_INIT_DELAY 750 | |||
#define REP_DELAY 25 | |||
// Mousekeys state | |||
bool inMouse = false; | |||
int8_t mousePress; | |||
// All processing done at chordUp goes through here | |||
// Note, this is a gutted version of the Georgi sten.h | |||
bool send_steno_chord_user(steno_mode_t mode, uint8_t chord[6]) { | |||
// Check for mousekeys, this is release | |||
#ifdef MOUSEKEY_ENABLE | |||
if (inMouse) { | |||
inMouse = false; | |||
mousekey_off(mousePress); | |||
mousekey_send(); | |||
} | |||
#endif | |||
// handle command mode | |||
if (cChord == (LSU | LSD | RD | RZ)) { | |||
if (cMode != COMMAND) { // Entering Command Mode | |||
CMDLEN = 0; | |||
pMode = cMode; | |||
cMode = COMMAND; | |||
} else { // Exiting Command Mode | |||
cMode = pMode; | |||
// Press all and release all | |||
for (int i = 0; i < CMDLEN; i++) { | |||
register_code(CMDBUF[i]); | |||
} | |||
clear_keyboard(); | |||
} | |||
goto out; | |||
} | |||
// Handle Gaming Toggle, | |||
if (cChord == (LSU | LSD | LFT | LK | RT | RS | RD | RZ) && keymapsCount > 1) { | |||
#ifndef NO_DEBUG | |||
uprintf("Switching to QMK\n"); | |||
#endif | |||
layer_on(1); | |||
goto out; | |||
} | |||
// Do QWERTY and Momentary QWERTY | |||
if (cMode == QWERTY || (cMode == COMMAND)) { | |||
processChord(false); | |||
goto out; | |||
} | |||
out: | |||
cChord = 0; | |||
inChord = false; | |||
chordIndex = 0; | |||
clear_keyboard(); | |||
repEngaged = false; | |||
for (int i = 0; i < 32; i++) | |||
chordState[i] = 0xFFFF; | |||
return false; | |||
} | |||
// Update Chord State | |||
bool process_steno_user(uint16_t keycode, keyrecord_t *record) { | |||
// Everything happens in here when steno keys come in. | |||
// Bail on keyup | |||
if (!record->event.pressed) return true; | |||
// Update key repeat timers | |||
repTimer = timer_read(); | |||
inChord = true; | |||
// Switch on the press adding to chord | |||
bool pr = record->event.pressed; | |||
switch (keycode) { | |||
// Mods and stuff | |||
case STN_ST1: pr ? (cChord |= (ST1)): (cChord &= ~(ST1)); break; | |||
case STN_ST2: pr ? (cChord |= (ST2)): (cChord &= ~(ST2)); break; | |||
case STN_ST3: pr ? (cChord |= (ST3)): (cChord &= ~(ST3)); break; | |||
case STN_ST4: pr ? (cChord |= (ST4)): (cChord &= ~(ST4)); break; | |||
case STN_FN: pr ? (cChord |= (FN)) : (cChord &= ~(FN)); break; | |||
case STN_PWR: pr ? (cChord |= (PWR)): (cChord &= ~(PWR)); break; | |||
case STN_N1...STN_N6: pr ? (cChord |= (LNO)): (cChord &= ~(LNO)); break; | |||
case STN_N7...STN_NC: pr ? (cChord |= (RNO)): (cChord &= ~(RNO)); break; | |||
// All the letter keys | |||
case STN_S1: pr ? (cChord |= (LSU)) : (cChord &= ~(LSU)); break; | |||
case STN_S2: pr ? (cChord |= (LSD)) : (cChord &= ~(LSD)); break; | |||
case STN_TL: pr ? (cChord |= (LFT)) : (cChord &= ~(LFT)); break; | |||
case STN_KL: pr ? (cChord |= (LK)) : (cChord &= ~(LK)); break; | |||
case STN_PL: pr ? (cChord |= (LP)) : (cChord &= ~(LP)); break; | |||
case STN_WL: pr ? (cChord |= (LW)) : (cChord &= ~(LW)); break; | |||
case STN_HL: pr ? (cChord |= (LH)) : (cChord &= ~(LH)); break; | |||
case STN_RL: pr ? (cChord |= (LR)) : (cChord &= ~(LR)); break; | |||
case STN_A: pr ? (cChord |= (LA)) : (cChord &= ~(LA)); break; | |||
case STN_O: pr ? (cChord |= (LO)) : (cChord &= ~(LO)); break; | |||
case STN_E: pr ? (cChord |= (RE)) : (cChord &= ~(RE)); break; | |||
case STN_U: pr ? (cChord |= (RU)) : (cChord &= ~(RU)); break; | |||
case STN_FR: pr ? (cChord |= (RF)) : (cChord &= ~(RF)); break; | |||
case STN_RR: pr ? (cChord |= (RR)) : (cChord &= ~(RR)); break; | |||
case STN_PR: pr ? (cChord |= (RP)) : (cChord &= ~(RP)); break; | |||
case STN_BR: pr ? (cChord |= (RB)) : (cChord &= ~(RB)); break; | |||
case STN_LR: pr ? (cChord |= (RL)) : (cChord &= ~(RL)); break; | |||
case STN_GR: pr ? (cChord |= (RG)) : (cChord &= ~(RG)); break; | |||
case STN_TR: pr ? (cChord |= (RT)) : (cChord &= ~(RT)); break; | |||
case STN_SR: pr ? (cChord |= (RS)) : (cChord &= ~(RS)); break; | |||
case STN_DR: pr ? (cChord |= (RD)) : (cChord &= ~(RD)); break; | |||
case STN_ZR: pr ? (cChord |= (RZ)) : (cChord &= ~(RZ)); break; | |||
} | |||
// Store previous state for fastQWER | |||
if (pr) { | |||
chordState[chordIndex] = cChord; | |||
chordIndex++; | |||
} | |||
return true; | |||
} | |||
void matrix_scan_user(void) { | |||
// We abuse this for early sending of key | |||
// Key repeat only on QWER/SYMB layers | |||
if (cMode != QWERTY || !inChord) return; | |||
// Check timers | |||
#ifndef NO_REPEAT | |||
if (repEngaged && timer_elapsed(repTimer) > REP_DELAY) { | |||
// Process Key for report | |||
processChord(false); | |||
// Send report to host | |||
send_keyboard_report(); | |||
clear_keyboard(); | |||
repTimer = timer_read(); | |||
} | |||
if (!repEngaged && timer_elapsed(repTimer) > REP_INIT_DELAY) { | |||
repEngaged = true; | |||
} | |||
#endif | |||
}; | |||
// For Plover NKRO | |||
uint32_t processFakeSteno(bool lookup) { | |||
P( LSU, SEND(KC_Q);); | |||
P( LSD, SEND(KC_A);); | |||
P( LFT, SEND(KC_W);); | |||
P( LP, SEND(KC_E);); | |||
P( LH, SEND(KC_R);); | |||
P( LK, SEND(KC_S);); | |||
P( LW, SEND(KC_D);); | |||
P( LR, SEND(KC_F);); | |||
P( ST1, SEND(KC_T);); | |||
P( ST2, SEND(KC_G);); | |||
P( LA, SEND(KC_C);); | |||
P( LO, SEND(KC_V);); | |||
P( RE, SEND(KC_N);); | |||
P( RU, SEND(KC_M);); | |||
P( ST3, SEND(KC_Y);); | |||
P( ST4, SEND(KC_H);); | |||
P( RF, SEND(KC_U);); | |||
P( RP, SEND(KC_I);); | |||
P( RL, SEND(KC_O);); | |||
P( RT, SEND(KC_P);); | |||
P( RD, SEND(KC_LBRC);); | |||
P( RR, SEND(KC_J);); | |||
P( RB, SEND(KC_K);); | |||
P( RG, SEND(KC_L);); | |||
P( RS, SEND(KC_SCLN);); | |||
P( RZ, SEND(KC_COMM);); | |||
P( LNO, SEND(KC_1);); | |||
P( RNO, SEND(KC_1);); | |||
return 0; | |||
} | |||
// Traverse the chord history to a given point | |||
// Returns the mask to use | |||
void processChord(bool useFakeSteno) { | |||
// Save the clean chord state | |||
uint32_t savedChord = cChord; | |||
// Apply Stick Bits if needed | |||
if (stickyBits != 0) { | |||
cChord |= stickyBits; | |||
for (int i = 0; i <= chordIndex; i++) | |||
chordState[i] |= stickyBits; | |||
} | |||
// Strip FN | |||
if (cChord & FN) cChord ^= FN; | |||
// First we test if a whole chord was passsed | |||
// If so we just run it handling repeat logic | |||
if (useFakeSteno && processFakeSteno(true) == cChord) { | |||
processFakeSteno(false); | |||
return; | |||
} else if (processQwerty(true) == cChord) { | |||
processQwerty(false); | |||
// Repeat logic | |||
if (repeatFlag) { | |||
restoreState(); | |||
repeatFlag = false; | |||
processChord(false); | |||
} else { | |||
saveState(cChord); | |||
} | |||
return; | |||
} | |||
// Iterate through chord picking out the individual | |||
// and longest chords | |||
uint32_t bufChords[QWERBUF]; | |||
int bufLen = 0; | |||
uint32_t mask = 0; | |||
// We iterate over it multiple times to catch the longest | |||
// chord. Then that gets addded to the mask and re run. | |||
while (savedChord != mask) { | |||
uint32_t test = 0; | |||
uint32_t longestChord = 0; | |||
for (int i = 0; i <= chordIndex; i++) { | |||
cChord = chordState[i] & ~mask; | |||
if (cChord == 0) | |||
continue; | |||
// Assume mid parse Sym is new chord | |||
if (i != 0 && test != 0 && (cChord ^ test) == PWR) { | |||
longestChord = test; | |||
break; | |||
} | |||
// Lock SYM layer in once detected | |||
if (mask & PWR) | |||
cChord |= PWR; | |||
// Testing for keycodes | |||
if (useFakeSteno) { | |||
test = processFakeSteno(true); | |||
} else { | |||
test = processQwerty(true); | |||
} | |||
if (test != 0) { | |||
longestChord = test; | |||
} | |||
} | |||
mask |= longestChord; | |||
bufChords[bufLen] = longestChord; | |||
bufLen++; | |||
// That's a loop of sorts, halt processing | |||
if (bufLen >= QWERBUF) { | |||
return; | |||
} | |||
} | |||
// Now that the buffer is populated, we run it | |||
for (int i = 0; i < bufLen ; i++) { | |||
cChord = bufChords[i]; | |||
if (useFakeSteno) { | |||
processFakeSteno(false); | |||
} else { | |||
processQwerty(false); | |||
} | |||
} | |||
// Save state in case of repeat | |||
if (!repeatFlag) { | |||
saveState(savedChord); | |||
} | |||
// Restore cChord for held repeat | |||
cChord = savedChord; | |||
return; | |||
} | |||
void saveState(uint32_t cleanChord) { | |||
pChord = cleanChord; | |||
pChordIndex = chordIndex; | |||
for (int i = 0; i < 32; i++) | |||
pChordState[i] = chordState[i]; | |||
} | |||
void restoreState() { | |||
cChord = pChord; | |||
chordIndex = pChordIndex; | |||
for (int i = 0; i < 32; i++) | |||
chordState[i] = pChordState[i]; | |||
} | |||
// Macros for calling from keymap.c | |||
void SEND(uint8_t kc) { | |||
// Send Keycode, Does not work for Quantum Codes | |||
if (cMode == COMMAND && CMDLEN < MAX_CMD_BUF) { | |||
#ifndef NO_DEBUG | |||
uprintf("CMD LEN: %d BUF: %d\n", CMDLEN, MAX_CMD_BUF); | |||
#endif | |||
CMDBUF[CMDLEN] = kc; | |||
CMDLEN++; | |||
} | |||
if (cMode != COMMAND) register_code(kc); | |||
return; | |||
} | |||
void REPEAT(void) { | |||
if (cMode != QWERTY) | |||
return; | |||
repeatFlag = true; | |||
return; | |||
} | |||
void SET_STICKY(uint32_t stick) { | |||
stickyBits = stick; | |||
return; | |||
} | |||
void SWITCH_LAYER(int layer) { | |||
if (keymapsCount >= layer) | |||
layer_on(layer); | |||
} | |||
void CLICK_MOUSE(uint8_t kc) { | |||
#ifdef MOUSEKEY_ENABLE | |||
mousekey_on(kc); | |||
mousekey_send(); | |||
// Store state for later use | |||
inMouse = true; | |||
mousePress = kc; | |||
#endif | |||
} |
@ -0,0 +1,77 @@ | |||
// 2019, g Heavy Industries | |||
// Blessed mother of Christ, please keep this readable | |||
// and protect us from segfaults. For thine is the clock, | |||
// the slave and the master. Until we return from main. | |||
// | |||
// Amen. | |||
#include QMK_KEYBOARD_H | |||
#include "mousekey.h" | |||
#include "keymap.h" | |||
#include "keymap_steno.h" | |||
#include "wait.h" | |||
extern size_t keymapsCount; // Total keymaps | |||
extern uint32_t cChord; // Current Chord | |||
// Function defs | |||
void processChord(bool useFakeSteno); | |||
uint32_t processQwerty(bool lookup); | |||
uint32_t processFakeSteno(bool lookup); | |||
void saveState(uint32_t cChord); | |||
void restoreState(void); | |||
// Macros for use in keymap.c | |||
void SEND(uint8_t kc); | |||
void REPEAT(void); | |||
void SET_STICKY(uint32_t); | |||
void SWITCH_LAYER(int); | |||
void CLICK_MOUSE(uint8_t); | |||
// Keymap helper | |||
#define P(chord, act) if (cChord == (chord)) { if (!lookup) {act;} return chord;} | |||
// Shift to internal representation | |||
// i.e) S(teno)R(ight)F | |||
#define STN(n) (1L<<n) | |||
enum ORDER { | |||
SFN = 0, SPWR, SST1, SST2, SST3, SST4, SNUML, SNUMR, | |||
SLSU, SLSD, SLT, SLK, SLP, SLW, SLH, SLR, SLA, SLO, | |||
SRE, SRU, SRF, SRR, SRP, SRB, SRL, SRG, SRT, SRS, SRD, SRZ, SRES1, SRES2 | |||
}; | |||
// Break it all out | |||
#define FN STN(SFN) | |||
#define PWR STN(SPWR) | |||
#define ST1 STN(SST1) | |||
#define ST2 STN(SST2) | |||
#define ST3 STN(SST3) | |||
#define ST4 STN(SST4) | |||
#define LNO STN(SNUML) // STN1-6 | |||
#define RNO STN(SNUMR) // STN7-C | |||
#define RES1 STN(SRES1) // Use reserved for sticky state | |||
#define RES2 STN(SRES2) | |||
#define LSU STN(SLSU) | |||
#define LSD STN(SLSD) | |||
#define LFT STN(SLT) // (L)e(F)t (T), preprocessor conflict | |||
#define LK STN(SLK) | |||
#define LP STN(SLP) | |||
#define LW STN(SLW) | |||
#define LH STN(SLH) | |||
#define LR STN(SLR) | |||
#define LA STN(SLA) | |||
#define LO STN(SLO) | |||
#define RE STN(SRE) | |||
#define RU STN(SRU) | |||
#define RF STN(SRF) | |||
#define RR STN(SRR) | |||
#define RP STN(SRP) | |||
#define RB STN(SRB) | |||
#define RL STN(SRL) | |||
#define RG STN(SRG) | |||
#define RT STN(SRT) | |||
#define RS STN(SRS) | |||
#define RD STN(SRD) | |||
#define RZ STN(SRZ) |
@ -0,0 +1,37 @@ | |||
/* | |||
Copyright 2012,2013 Jun Wako <wakojun@gmail.com> | |||
This program is free software: you can redistribute it and/or modify | |||
it under the terms of the GNU General Public License as published by | |||
the Free Software Foundation, either version 2 of the License, or | |||
(at your option) any later version. | |||
This program is distributed in the hope that it will be useful, | |||
but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |||
GNU General Public License for more details. | |||
You should have received a copy of the GNU General Public License | |||
along with this program. If not, see <http://www.gnu.org/licenses/>. | |||
*/ | |||
#include QMK_KEYBOARD_H | |||
const uint16_t keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
[0] = LAYOUT_all( | |||
KC_ESC, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, | |||
KC_GRV, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_MINS, KC_EQL, KC_BSPC, KC_DEL, ENC_PRESS, | |||
KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_LBRC, KC_RBRC, KC_BSLS, KC_PGUP, | |||
KC_CAPS, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, KC_NUHS, KC_ENTER, KC_PGDN, | |||
KC_LSFT, KC_NUBS, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_RSFT, KC_UP, MO(1), | |||
KC_LCTL, KC_LGUI, KC_LALT, KC_SPC, KC_SPC, KC_SPC, KC_RALT, MO(1), KC_RCTL, KC_LEFT, KC_DOWN, KC_RGHT | |||
), | |||
[1] = LAYOUT_all( | |||
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, | |||
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_DEL, _______, OLED_TOGG, | |||
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, CLOCK_SET, | |||
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, | |||
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, | |||
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______ | |||
) | |||
}; |
@ -1 +1,5 @@ | |||
# The default keymap for doro67 | |||
**THIS IS THE DEFAULT KEYMAP DIRECTORY (AVAILABILITY: CHINA GB ONLY)** | |||
If you are a non-china buyer, you probably have the multi PCB or rgb PCB. | |||
Please look at the "multi" and "rgb" readme files. |
@ -1 +1,7 @@ | |||
# The default keymap for rgb | |||
**RGB PCB (AVAILABILITY: CHINA + INTERNATIONAL GB)** | |||
The "rgb" directory includes the keymap for the RGB PCB. | |||
The multi-layout PCB and RGB pcb were the only two options available to NON-china buyers. | |||
If you purchased a non-rgb PCB, please see the 'multi' directory. |
@ -0,0 +1,25 @@ | |||
#include QMK_KEYBOARD_H | |||
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
LAYOUT( | |||
KC_GESC, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_MINS, KC_EQL, KC_NO, KC_BSPC, | |||
KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_LBRC, KC_RBRC, KC_BSLS, | |||
KC_LCTL, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, KC_ENT, | |||
KC_LSFT, KC_NO, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_RSFT, KC_NO, | |||
KC_CAPS, KC_LGUI, KC_LALT, KC_SPC, KC_SPC, KC_SPC, KC_RALT, MO(2), KC_NO, MO(1), KC_RCTL), | |||
LAYOUT( | |||
KC_GRV, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, KC_TRNS, KC_DEL, | |||
KC_TRNS, KC_PGUP, KC_UP, KC_PGDN, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, | |||
KC_TRNS, KC_LEFT, KC_DOWN, KC_RIGHT, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, | |||
KC_TRNS, KC_TRNS, KC_SCROLLLOCK, KC_PAUSE, KC_HOME, KC_END, KC_INSERT, KC_PSCR, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, | |||
KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS), | |||
LAYOUT( | |||
RESET, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, | |||
KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, | |||
KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, | |||
KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, | |||
KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS), | |||
}; |
@ -0,0 +1,50 @@ | |||
{ | |||
"keyboard_name": "NQG (Not Quite Gherkin)", | |||
"url": "", | |||
"maintainer": "culturalsnow", | |||
"width": 11, | |||
"height": 4, | |||
"layouts": { | |||
"LAYOUT": { | |||
"layout": [ | |||
{"label":"Q", "x":1, "y":0}, | |||
{"label":"W", "x":2, "y":0}, | |||
{"label":"E", "x":3, "y":0}, | |||
{"label":"R", "x":4, "y":0}, | |||
{"label":"T", "x":5, "y":0}, | |||
{"label":"Y", "x":6, "y":0}, | |||
{"label":"U", "x":7, "y":0}, | |||
{"label":"I", "x":8, "y":0}, | |||
{"label":"O", "x":9, "y":0}, | |||
{"label":"P", "x":10, "y":0}, | |||
{"label":"A", "x":1, "y":1}, | |||
{"label":"S", "x":2, "y":1}, | |||
{"label":"D", "x":3, "y":1}, | |||
{"label":"F", "x":4, "y":1}, | |||
{"label":"G", "x":5, "y":1}, | |||
{"label":"H", "x":6, "y":1}, | |||
{"label":"J", "x":7, "y":1}, | |||
{"label":"K", "x":8, "y":1}, | |||
{"label":"L", "x":9, "y":1}, | |||
{"label":"; '", "x":10, "y":1}, | |||
{"label":"Z", "x":1, "y":2}, | |||
{"label":"X", "x":2, "y":2}, | |||
{"label":"C", "x":3, "y":2}, | |||
{"label":"V", "x":4, "y":2}, | |||
{"label":"B", "x":5, "y":2}, | |||
{"label":"N", "x":6, "y":2}, | |||
{"label":"M", "x":7, "y":2}, | |||
{"label":",", "x":8, "y":2}, | |||
{"label":".", "x":9, "y":2}, | |||
{"label":"/ Enter", "x":10, "y":2}, | |||
{"label":"Shift / Tab", "x":0, "y":2}, | |||
{"label":"LT(_LOWER, KC_ESC)", "x":3, "y":3}, | |||
{"label":"Ctrl / Backspace", "x":4, "y":3}, | |||
{"label":"Ctrl / Backspace", "x":5, "y":3}, | |||
{"label":"Space", "x":6, "y":3}, | |||
{"label":"Space", "x":7, "y":3}, | |||
{"label":"MO(_RAISE)", "x":8, "y":3} | |||
] | |||
} | |||
} | |||
} |
@ -1,178 +0,0 @@ | |||
#ifndef _I2CMASTER_H | |||
#define _I2CMASTER_H 1 | |||
/************************************************************************* | |||
* Title: C include file for the I2C master interface | |||
* (i2cmaster.S or twimaster.c) | |||
* Author: Peter Fleury <pfleury@gmx.ch> http://jump.to/fleury | |||
* File: $Id: i2cmaster.h,v 1.10 2005/03/06 22:39:57 Peter Exp $ | |||
* Software: AVR-GCC 3.4.3 / avr-libc 1.2.3 | |||
* Target: any AVR device | |||
* Usage: see Doxygen manual | |||
**************************************************************************/ | |||
#ifdef DOXYGEN | |||
/** | |||
@defgroup pfleury_ic2master I2C Master library | |||
@code #include <i2cmaster.h> @endcode | |||
@brief I2C (TWI) Master Software Library | |||
Basic routines for communicating with I2C slave devices. This single master | |||
implementation is limited to one bus master on the I2C bus. | |||
This I2c library is implemented as a compact assembler software implementation of the I2C protocol | |||
which runs on any AVR (i2cmaster.S) and as a TWI hardware interface for all AVR with built-in TWI hardware (twimaster.c). | |||
Since the API for these two implementations is exactly the same, an application can be linked either against the | |||
software I2C implementation or the hardware I2C implementation. | |||
Use 4.7k pull-up resistor on the SDA and SCL pin. | |||
Adapt the SCL and SDA port and pin definitions and eventually the delay routine in the module | |||
i2cmaster.S to your target when using the software I2C implementation ! | |||
Adjust the CPU clock frequence F_CPU in twimaster.c or in the Makfile when using the TWI hardware implementaion. | |||
@note | |||
The module i2cmaster.S is based on the Atmel Application Note AVR300, corrected and adapted | |||
to GNU assembler and AVR-GCC C call interface. | |||
Replaced the incorrect quarter period delays found in AVR300 with | |||
half period delays. | |||
@author Peter Fleury pfleury@gmx.ch http://jump.to/fleury | |||
@par API Usage Example | |||
The following code shows typical usage of this library, see example test_i2cmaster.c | |||
@code | |||
#include <i2cmaster.h> | |||
#define Dev24C02 0xA2 // device address of EEPROM 24C02, see datasheet | |||
int main(void) | |||
{ | |||
unsigned char ret; | |||
i2c_init(); // initialize I2C library | |||
// write 0x75 to EEPROM address 5 (Byte Write) | |||
i2c_start_wait(Dev24C02+I2C_WRITE); // set device address and write mode | |||
i2c_write(0x05); // write address = 5 | |||
i2c_write(0x75); // write value 0x75 to EEPROM | |||
i2c_stop(); // set stop conditon = release bus | |||
// read previously written value back from EEPROM address 5 | |||
i2c_start_wait(Dev24C02+I2C_WRITE); // set device address and write mode | |||
i2c_write(0x05); // write address = 5 | |||
i2c_rep_start(Dev24C02+I2C_READ); // set device address and read mode | |||
ret = i2c_readNak(); // read one byte from EEPROM | |||
i2c_stop(); | |||
for(;;); | |||
} | |||
@endcode | |||
*/ | |||
#endif /* DOXYGEN */ | |||
/**@{*/ | |||
#if (__GNUC__ * 100 + __GNUC_MINOR__) < 304 | |||
#error "This library requires AVR-GCC 3.4 or later, update to newer AVR-GCC compiler !" | |||
#endif | |||
#include <avr/io.h> | |||
/** defines the data direction (reading from I2C device) in i2c_start(),i2c_rep_start() */ | |||
#define I2C_READ 1 | |||
/** defines the data direction (writing to I2C device) in i2c_start(),i2c_rep_start() */ | |||
#define I2C_WRITE 0 | |||
/** | |||
@brief initialize the I2C master interace. Need to be called only once | |||
@param void | |||
@return none | |||
*/ | |||
void i2c_init(void); | |||
/** | |||
@brief Terminates the data transfer and releases the I2C bus | |||
@param void | |||
@return none | |||
*/ | |||
void i2c_stop(void); | |||
/** | |||
@brief Issues a start condition and sends address and transfer direction | |||
@param addr address and transfer direction of I2C device | |||
@retval 0 device accessible | |||
@retval 1 failed to access device | |||
*/ | |||
unsigned char i2c_start(unsigned char addr); | |||
/** | |||
@brief Issues a repeated start condition and sends address and transfer direction | |||
@param addr address and transfer direction of I2C device | |||
@retval 0 device accessible | |||
@retval 1 failed to access device | |||
*/ | |||
unsigned char i2c_rep_start(unsigned char addr); | |||
/** | |||
@brief Issues a start condition and sends address and transfer direction | |||
If device is busy, use ack polling to wait until device ready | |||
@param addr address and transfer direction of I2C device | |||
@return none | |||
*/ | |||
void i2c_start_wait(unsigned char addr); | |||
/** | |||
@brief Send one byte to I2C device | |||
@param data byte to be transfered | |||
@retval 0 write successful | |||
@retval 1 write failed | |||
*/ | |||
unsigned char i2c_write(unsigned char data); | |||
/** | |||
@brief read one byte from the I2C device, request more data from device | |||
@return byte read from I2C device | |||
*/ | |||
unsigned char i2c_readAck(void); | |||
/** | |||
@brief read one byte from the I2C device, read is followed by a stop condition | |||
@return byte read from I2C device | |||
*/ | |||
unsigned char i2c_readNak(void); | |||
/** | |||
@brief read one byte from the I2C device | |||
Implemented as a macro, which calls either i2c_readAck or i2c_readNak | |||
@param ack 1 send ack, request more data from device<br> | |||
0 send nak, read is followed by a stop condition | |||
@return byte read from I2C device | |||
*/ | |||
unsigned char i2c_read(unsigned char ack); | |||
#define i2c_read(ack) (ack) ? i2c_readAck() : i2c_readNak(); | |||
/**@}*/ | |||
#endif |
@ -0,0 +1,174 @@ | |||
/* Good on you for modifying your layout! if you don't have | |||
* time to read the QMK docs, a list of keycodes can be found at | |||
* | |||
* https://github.com/qmk/qmk_firmware/blob/master/docs/keycodes.md | |||
* | |||
* There's also a template for adding new layers at the bottom of this file! | |||
*/ | |||
#include QMK_KEYBOARD_H | |||
#define IGNORE_MOD_TAP_INTERRUPT | |||
#define BASE 0 // default layer | |||
#define SYMB 1 // symbols | |||
#define NUMB 2 // numbers/motion | |||
enum custom_keycodes { | |||
M1_STRING = SAFE_RANGE, | |||
M2_URL, | |||
}; | |||
// Blank template at the bottom | |||
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
/* Keymap 0: Basic layer | |||
* | |||
* ,-------------------------------------------. ,-------------------------------------------. | |||
* | TAB | Q | W | F | P | G | | J | L | U | Y | ; : | | \ | | |||
* |--------+------+------+------+------+------|------. .------|------+------+------+------+------+--------| | |||
* | Ctrl | A | R | S | T | D |O(CMD)| |O(CTL)| H | N | E | I | O | ' " | | |||
* |--------+------+------+------+------+------|------| |------|------+------+------+------+------+--------| | |||
* | LShift | Z | X | C | V | B |O(ALT)| | | K | M | , < | . > | / ? | RShift | | |||
* `--------+------+------+------+------+-------------' `-------------+------+------+------+------+--------' | |||
* .----------. .-------. .------. .--------. | |||
* | alt/del | | BKSP | | Space| |cmd/del | | |||
* '----------' '-------' `------. '--------' | |||
* ,-------. ,-------. | |||
* | MMB | | : | | |||
* ,------|-------| |-------|------. | |||
* | NUMB | SYMB | | SYMB | NUMB | | |||
* | Esc | F13 | | F14 | Enter| | |||
* | | | | | | | |||
* `--------------' `--------------' | |||
*/ | |||
[BASE] = LAYOUT_gergo( | |||
KC_TAB, KC_Q, KC_W, KC_F, KC_P, KC_G, KC_J, KC_L, KC_U, KC_Y,KC_SCLN, KC_BSLS, | |||
KC_LCTL, KC_A, KC_R, KC_S, KC_T, KC_D, OSM(MOD_LGUI), OSM(MOD_LCTL), KC_H, KC_N, KC_E, KC_I, KC_O, KC_QUOT, | |||
KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, OSM(MOD_LALT), KC_TRNS, KC_K, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_RSFT, | |||
ALT_T(KC_DEL), KC_BSPC, KC_SPC, CMD_T(KC_DEL), | |||
KC_BTN3, KC_COLON, | |||
LT(SYMB, KC_ESC), LT(NUMB, KC_F13), LT(NUMB, KC_F14), LT(SYMB, KC_ENT)), | |||
/* Keymap 1: Symbols layer | |||
* | |||
* ,-------------------------------------------. ,-------------------------------------------. | |||
* | | ! | @ | # | $ | % | | ^ | & | * | ( | ) | VolUp | | |||
* |--------+------+------+------+------+------|------. .------|------+------+------+------+------+--------| | |||
* | | [ | ] | { | } | ` | M1 | | | | - | _ | + | = | VolDn | | |||
* |--------+------+------+------+------+------|------| |------|------+------+------+------+------+--------| | |||
* | | ` | ~ | | | ~ | M2 | | | | | Prev |Pl/Pau| Next | Mute | | |||
* `--------+------+------+------+------+-------------' `-------------+------+------+------+------+--------' | |||
* .------. .------. .------. .-----. | |||
* | | | | | | | | | |||
* '------' '------' `------. '-----' | |||
* ,-------. ,-------. | |||
* | | | | | |||
* ,------|-------| |-------|------. | |||
* | | | | | | | |||
* | | | | | | | |||
* | | | | | | | |||
* `--------------' `--------------' | |||
*/ | |||
[SYMB] = LAYOUT_gergo( | |||
KC_TRNS, KC_EXLM, KC_AT, KC_HASH,KC_DLR, KC_PERC, KC_CIRC, KC_AMPR, KC_ASTR, KC_LPRN, KC_RPRN, KC__VOLUP, | |||
KC_TRNS, KC_LBRC, KC_RBRC, KC_LCBR,KC_RCBR, KC_PLUS, M1_STRING, KC_TRNS, KC_TRNS, KC_MINS, KC_UNDERSCORE, KC_PLUS, KC_EQL, KC__VOLDOWN, | |||
KC_TRNS, KC_GRV, KC_TILD,KC_TRNS,KC_TRNS, KC_EQL, M2_URL, KC_TRNS, KC_TRNS, KC_TRNS, KC_MEDIA_REWIND, KC_MEDIA_PLAY_PAUSE, KC_MEDIA_FAST_FORWARD, KC__MUTE, | |||
KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, | |||
KC_TRNS, KC_TRNS, | |||
KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS), | |||
/* Keymap 2: Pad/Function layer | |||
* | |||
* ,-------------------------------------------. ,-------------------------------------------. | |||
* | | 1 | 2 | 3 | 4 | 5 | | 6 | 7 | 8 | 9 | 0 | PgUp | | |||
* |--------+------+------+------+------+------|------. .------|------+------+------+------+------+--------| | |||
* | F1 | F2 | F3 | F4 | F5 | F6 | BTN1 | | Home | LEFT | DOWN | UP | RIGHT| End | PgDn | | |||
* |--------+------+------+------+------+------|------| |------|------+------+------+------+------+--------| | |||
* | F7 | F8 | F9 | F10 | F11 | F12 | BTN2 | | | MLFT | MDWN | MUP | MRGHT| | | | |||
* `--------+------+------+------+------+-------------' `-------------+------+------+------+------+--------' | |||
* .------. .------. .------. .-----. | |||
* | | | | | ALT | | | | |||
* '------' '------' `------. '-----' | |||
* ,-------. ,-------. | |||
* | | | | | |||
* ,------|-------| |-------|------. | |||
* | | | | | | | |||
* | | | | | | | |||
* | | | | | | | |||
* `--------------' `--------------' | |||
*/ | |||
[NUMB] = LAYOUT_gergo( | |||
KC_TRNS, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_PGUP, | |||
KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_BTN1, KC_HOME, KC_LEFT, KC_DOWN, KC_UP, KC_RGHT, KC_END, KC_PGDN, | |||
KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, KC_BTN2, KC_TRNS, KC_MS_L, KC_MS_D, KC_MS_U, KC_MS_R, KC_TRNS, KC_TRNS, | |||
KC_TRNS, KC_TRNS, KC_RALT, KC_TRNS, | |||
KC_TRNS, KC_TRNS, | |||
KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS) | |||
}; | |||
/* Keymap template | |||
* | |||
* ,-------------------------------------------. ,-------------------------------------------. | |||
* | | | | | | | | | | | | | | | |||
* |--------+------+------+------+------+------|------. .------|------+------+------+------+------+--------| | |||
* | | | | | | | | | | | | | | | | | |||
* |--------+------+------+------+------+------|------| |------|------+------+------+------+------+--------| | |||
* | | | | | | | | | | | | | | | | | |||
* `--------+------+------+------+------+-------------' `-------------+------+------+------+------+--------' | |||
* .------. .------. .------. .-----. | |||
* | | | | | | | | | |||
* '------' '------' `------. '-----' | |||
* ,-------. ,-------. | |||
* | | | | | |||
* ,------|-------| |-------|------. | |||
* | | | | | | | |||
* | | | | | | | |||
* | | | | | | | |||
* `--------------' `--------------' | |||
[SYMB] = LAYOUT_gergo( | |||
KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, | |||
KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, | |||
KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, | |||
KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, | |||
KC_TRNS, KC_TRNS, | |||
KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS), | |||
*/ | |||
// Runs just one time when the keyboard initializes. | |||
void matrix_init_user(void) { | |||
}; | |||
// Runs constantly in the background, in a loop. | |||
void matrix_scan_user(void) { | |||
//uint8_t layer = biton32(layer_state); | |||
biton32(layer_state); | |||
}; | |||
bool process_record_user(uint16_t keycode, keyrecord_t *record) { | |||
switch (keycode) { | |||
case M1_STRING: | |||
if (record->event.pressed) { | |||
// when keycode QMKBEST is pressed | |||
SEND_STRING("Hi!" SS_TAP(X_ENTER)); | |||
} else { | |||
// when keycode QMKBEST is released | |||
} | |||
break; | |||
case M2_URL: | |||
if (record->event.pressed) { | |||
SEND_STRING("https://ddg.gg" SS_TAP(X_ENTER)); | |||
} | |||
break; | |||
} | |||
return true; | |||
}; | |||
@ -0,0 +1,16 @@ | |||
# [Gergo! By g Heavy Industries](http://gboards.ca) | |||
![Gergo image](https://4.bp.blogspot.com/-889nMXxgSM0/XCNxwnO5kUI/AAAAAAAA6mI/tZbWgZVCBW0dyZOCGJDkjN06DVax7j8XwCLcBGAs/s1600/48422820_967732713413298_485744639215665152_n.jpg) | |||
This is a [Colemak](https://colemak.com/) mapping for the Gergo, | |||
Unlike the default mapping, most symbols are at their original place on the number row to ease in the | |||
learning curve. | |||
You can view this layout over at | |||
[keyboad-layout-editor.com](http://www.keyboard-layout-editor.com/#/gists/f04d6a3b0cd3db91407c51f7ba36aeb3). | |||
## Settings | |||
To edit various settings, enable the 1u trackball and whatnot please modify /keyboards/gergo/keymaps/default/rules.mk | |||
Ideally you should copy this directory and make your changes there. If you come up with a good layout submit a PR! |
@ -0,0 +1,36 @@ | |||
#---------------------------------------------------------------------------- | |||
# make gergo:germ:dfu | |||
# Make sure you have dfu-programmer installed! | |||
#---------------------------------------------------------------------------- | |||
# Firmware options | |||
BALLER = no # Enable to ball out | |||
BALLSTEP = 20 # Multiple in px to move, multiplied by layer number | |||
SCROLLSTEP = 1 # Lines to scroll with ball | |||
MOUSEKEY_ENABLE = yes # Mouse keys(+4700), needed for baller | |||
#Debug options | |||
VERBOSE = no | |||
DEBUG_MATRIX_SCAN_RATE = no | |||
DEBUG_BALLER = no | |||
DEBUG_MATRIX = no | |||
# A bunch of stuff that you shouldn't touch unless you | |||
# know what you're doing. | |||
# | |||
# No touchy, capiche? | |||
SRC += matrix.c i2c_master.c | |||
ifneq ($(strip $(BALLSTEP)),) | |||
OPT_DEFS += -DTRKSTEP=$(strip $(BALLSTEP)) | |||
endif | |||
ifneq ($(strip $(SCROLLSTEP)),) | |||
OPT_DEFS += -DSCROLLSTEP=$(strip $(SCROLLSTEP)) | |||
endif | |||
ifeq ($(strip $(BALLER)), yes) | |||
OPT_DEFS += -DBALLER | |||
endif | |||
ifeq ($(strip $(DEBUG_BALLER)), yes) | |||
OPT_DEFS += -DDEBUG_BALLER | |||
endif | |||
ifeq ($(strip $(DEBUG_MATRIX)), yes) | |||
OPT_DEFS += -DDEBUG_MATRIX | |||
endif |
@ -0,0 +1,3 @@ | |||
#pragma once | |||
#define IGNORE_MOD_TAP_INTERRUPT |
@ -0,0 +1,119 @@ | |||
/* Good on you for modifying your layout! if you don't have | |||
* time to read the QMK docs, a list of keycodes can be found at | |||
* | |||
* https://github.com/qmk/qmk_firmware/blob/master/docs/keycodes.md | |||
* | |||
* There's also a template for adding new layers at the bottom of this file! | |||
*/ | |||
#include QMK_KEYBOARD_H | |||
#include "drashna.h" | |||
// Blank template at the bottom | |||
enum customKeycodes { | |||
URL = 1 | |||
}; | |||
#define LAYOUT_gergo_wrapper(...) LAYOUT_gergo(__VA_ARGS__) | |||
#define LAYOUT_gergo_base( \ | |||
K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, \ | |||
K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, \ | |||
K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A \ | |||
) \ | |||
LAYOUT_gergo_wrapper( \ | |||
KC_ESC, K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, KC_PIPE, \ | |||
KC_TAB, ALT_T(K11), K12, K13, K14, K15, _______, _______, K16, K17, K18, K19, K1A, RGUI_T(KC_QUOT), \ | |||
OS_LSFT, CTL_T(K21), K22, K23, K24, K25, _______, _______, _______, _______, K26, K27, K28, K29, CTL_T(K2A), OS_RSFT, \ | |||
_______, _______, KC_SPC, LT(_LOWER, KC_BSPC), LT(_RAISE, KC_DEL), KC_ENT, _______, _______ \ | |||
) | |||
#define LAYOUT_gergo_base_wrapper(...) LAYOUT_gergo_base(__VA_ARGS__) | |||
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
[_QWERTY] = LAYOUT_gergo_base_wrapper( | |||
_________________QWERTY_L1_________________, _________________QWERTY_R1_________________, | |||
_________________QWERTY_L2_________________, _________________QWERTY_R2_________________, | |||
_________________QWERTY_L3_________________, _________________QWERTY_R3_________________ | |||
), | |||
[_COLEMAK] = LAYOUT_gergo_base_wrapper( | |||
_________________COLEMAK_L1________________, _________________COLEMAK_R1________________, | |||
_________________COLEMAK_L2________________, _________________COLEMAK_R2________________, | |||
_________________COLEMAK_L3________________, _________________COLEMAK_R3________________ | |||
), | |||
[_DVORAK] = LAYOUT_gergo_base_wrapper( | |||
_________________DVORAK_L1_________________, _________________DVORAK_R1_________________, | |||
_________________DVORAK_L2_________________, _________________DVORAK_R2_________________, | |||
_________________DVORAK_L3_________________, _________________DVORAK_R3_________________ | |||
), | |||
[_WORKMAN] = LAYOUT_gergo_base_wrapper( | |||
_________________WORKMAN_L1________________, _________________WORKMAN_R1________________, | |||
_________________WORKMAN_L2________________, _________________WORKMAN_R2________________, | |||
_________________WORKMAN_L3________________, _________________WORKMAN_R3________________ | |||
), | |||
[_NORMAN] = LAYOUT_gergo_base_wrapper( | |||
_________________NORMAN_L1_________________, _________________NORMAN_L1_________________, | |||
_________________NORMAN_L2_________________, _________________NORMAN_R2_________________, | |||
_________________NORMAN_L3_________________, _________________NORMAN_R3_________________ | |||
), | |||
[_MALTRON] = LAYOUT_gergo_base_wrapper( | |||
_________________MALTRON_L1________________, _________________MALTRON_R1________________, | |||
_________________MALTRON_L2________________, _________________MALTRON_R2________________, | |||
_________________MALTRON_L3________________, _________________MALTRON_R3________________ | |||
), | |||
[_EUCALYN] = LAYOUT_gergo_base_wrapper( | |||
_________________EUCALYN_L1________________, _________________EUCALYN_R1________________, | |||
_________________EUCALYN_L2________________, _________________EUCALYN_R2________________, | |||
_________________EUCALYN_L3________________, _________________EUCALYN_R3________________ | |||
), | |||
[_CARPLAX] = LAYOUT_gergo_base_wrapper( | |||
_____________CARPLAX_QFMLWY_L1_____________, _____________CARPLAX_QFMLWY_R1_____________, | |||
_____________CARPLAX_QFMLWY_L2_____________, _____________CARPLAX_QFMLWY_R2_____________, | |||
_____________CARPLAX_QFMLWY_L3_____________, _____________CARPLAX_QFMLWY_R3_____________ | |||
), | |||
[_MODS] = LAYOUT_gergo_wrapper( | |||
_______, ___________________BLANK___________________, ___________________BLANK___________________, _______, | |||
_______, ___________________BLANK___________________, _______, _______, ___________________BLANK___________________, _______, | |||
KC_LSFT, ___________________BLANK___________________, _______, _______, _______, _______, ___________________BLANK___________________, KC_RSFT, | |||
_______, _______, _______, _______, _______, _______, _______, _______ | |||
), | |||
[_LOWER] = LAYOUT_gergo_wrapper( | |||
KC_F12, _________________LOWER_L1__________________, _________________LOWER_R1__________________, KC_F11, | |||
_______, _________________LOWER_L2__________________, _______, _______, _________________LOWER_R2__________________, KC_PIPE, | |||
_______, _________________LOWER_L3__________________, _______, _______, _______, _______, _________________LOWER_R3__________________, _______, | |||
_______, _______, _______, _______, _______, _______, _______, _______ | |||
), | |||
[_RAISE] = LAYOUT_gergo_wrapper( | |||
_______, _________________RAISE_L1__________________, _________________RAISE_R1__________________, _______, | |||
_______, _________________RAISE_L2__________________, _______, _______, _________________RAISE_R2__________________, KC_BSLS, | |||
_______, _________________RAISE_L3__________________, _______, _______, _______, _______, _________________RAISE_R3__________________, _______, | |||
_______, _______, _______, _______, _______, _______, _______, _______ | |||
), | |||
[_ADJUST] = LAYOUT_gergo_wrapper( | |||
KC_MAKE, _________________ADJUST_L1_________________, _________________ADJUST_R1_________________, KC_RESET, | |||
VRSN, _________________ADJUST_L2_________________, _______, KC_NUKE, _________________ADJUST_R2_________________, EEP_RST, | |||
_______, _________________ADJUST_L3_________________, _______, _______, _______, _______, _________________ADJUST_R3_________________, TG_MODS, | |||
_______, _______, _______, _______, _______, _______, _______, _______ | |||
), | |||
}; | |||
/* Keymap template | |||
[SYMB] = LAYOUT_gergo_wrapper( | |||
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, | |||
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, | |||
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, | |||
_______, _______, _______, _______, _______, _______, _______, _______ | |||
), | |||
*/ |
@ -0,0 +1,3 @@ | |||
#pragma once | |||
#define IGNORE_MOD_TAP_INTERRUPT |
@ -1,47 +0,0 @@ | |||
/* Copyright 2018 Josh Hinnebusch | |||
* | |||
* This program is free software: you can redistribute it and/or modify | |||
* it under the terms of the GNU General Public License as published by | |||
* the Free Software Foundation, either version 2 of the License, or | |||
* (at your option) any later version. | |||
* | |||
* This program is distributed in the hope that it will be useful, | |||
* but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |||
* GNU General Public License for more details. | |||
* | |||
* You should have received a copy of the GNU General Public License | |||
* along with this program. If not, see <http://www.gnu.org/licenses/>. | |||
*/ | |||
#ifndef H87A_H | |||
#define H87A_H | |||
#include "quantum.h" | |||
// This a shortcut to help you visually see your layout. | |||
// The following is an example using the Planck MIT layout | |||
// The first section contains all of the arguments | |||
// The second converts the arguments into a two-dimensional array | |||
#define LAYOUT_all(\ | |||
K000, K001, K011, K002, K012, K003, K013, K004, K014, K015, K006, K016, K007, K017, K008, K018, \ | |||
K020, K030, K021, K031, K022, K032, K023, K033, K024, K034, K025, K035, K026, K036, K027, K037, K028, K038, \ | |||
K040, K050, K041, K051, K042, K052, K043, K053, K044, K054, K045, K055, K046, K056, K057, K048, K058, \ | |||
K060, K070, K061, K071, K062, K072, K063, K073, K064, K074, K065, K075, K066, K076, \ | |||
K080, K090, K081, K091, K082, K092, K083, K093, K084, K094, K085, K095, K086, K096, K088, \ | |||
K100, K110, K101, K113, K105, K115, K106, K116, K117, K108, K118 \ | |||
) { \ | |||
{ K000, K001, K002, K003, K004, KC_NO, K006, K007, K008 }, \ | |||
{ KC_NO, K011, K012, K013, K014, K015, K016, K017, K018 }, \ | |||
{ K020, K021, K022, K023, K024, K025, K026, K027, K028 }, \ | |||
{ K030, K031, K032, K033, K034, K035, K036, K037, K038 }, \ | |||
{ K040, K041, K042, K043, K044, K045, K046, KC_NO, K048 }, \ | |||
{ K050, K051, K052, K053, K054, K055, K056, K057, K058 }, \ | |||
{ K060, K061, K062, K063, K064, K065, K066, KC_NO, KC_NO }, \ | |||
{ K070, K071, K072, K073, K074, K075, K076, KC_NO, KC_NO }, \ | |||
{ K080, K081, K082, K083, K084, K085, K086, KC_NO, K088 }, \ | |||
{ K090, K091, K092, K093, K094, K095, K096, KC_NO, KC_NO }, \ | |||
{ K100, K101, KC_NO, KC_NO, KC_NO, K105, K106, KC_NO, K108 }, \ | |||
{ K110, KC_NO, KC_NO, K113, KC_NO, K115, K116, K117, K118 } \ | |||
} | |||
#endif |
@ -1,12 +0,0 @@ | |||
{ | |||
"keyboard_name": "h87a", | |||
"url": "", | |||
"maintainer": "hineybush", | |||
"width": 18.25, | |||
"height": 6.5, | |||
"layouts": { | |||
"LAYOUT_all": { | |||
"layout": [{"label":"Esc", "x":0, "y":0}, {"label":"F1", "x":2, "y":0}, {"label":"F2", "x":3, "y":0}, {"label":"F3", "x":4, "y":0}, {"label":"F4", "x":5, "y":0}, {"label":"F5", "x":6.5, "y":0}, {"label":"F6", "x":7.5, "y":0}, {"label":"F7", "x":8.5, "y":0}, {"label":"F8", "x":9.5, "y":0}, {"label":"F9", "x":11, "y":0}, {"label":"F10", "x":12, "y":0}, {"label":"F11", "x":13, "y":0}, {"label":"F12", "x":14, "y":0}, {"label":"PrtSc", "x":15.25, "y":0}, {"label":"Scroll Lock", "x":16.25, "y":0}, {"label":"Pause", "x":17.25, "y":0}, {"label":"~", "x":0, "y":1.5}, {"label":"!", "x":1, "y":1.5}, {"label":"@", "x":2, "y":1.5}, {"label":"#", "x":3, "y":1.5}, {"label":"$", "x":4, "y":1.5}, {"label":"%", "x":5, "y":1.5}, {"label":"^", "x":6, "y":1.5}, {"label":"&", "x":7, "y":1.5}, {"label":"*", "x":8, "y":1.5}, {"label":"(", "x":9, "y":1.5}, {"label":")", "x":10, "y":1.5}, {"label":"_", "x":11, "y":1.5}, {"label":"+", "x":12, "y":1.5}, {"x":13, "y":1.5}, {"x":14, "y":1.5}, {"label":"Insert", "x":15.25, "y":1.5}, {"label":"Home", "x":16.25, "y":1.5}, {"label":"PgUp", "x":17.25, "y":1.5}, {"label":"Tab", "x":0, "y":2.5, "w":1.5}, {"label":"Q", "x":1.5, "y":2.5}, {"label":"W", "x":2.5, "y":2.5}, {"label":"E", "x":3.5, "y":2.5}, {"label":"R", "x":4.5, "y":2.5}, {"label":"T", "x":5.5, "y":2.5}, {"label":"Y", "x":6.5, "y":2.5}, {"label":"U", "x":7.5, "y":2.5}, {"label":"I", "x":8.5, "y":2.5}, {"label":"O", "x":9.5, "y":2.5}, {"label":"P", "x":10.5, "y":2.5}, {"label":"{", "x":11.5, "y":2.5}, {"label":"}", "x":12.5, "y":2.5}, {"label":"|", "x":13.5, "y":2.5, "w":1.5}, {"label":"Delete", "x":15.25, "y":2.5}, {"label":"End", "x":16.25, "y":2.5}, {"label":"PgDn", "x":17.25, "y":2.5}, {"label":"Caps Lock", "x":0, "y":3.5, "w":1.75}, {"label":"A", "x":1.75, "y":3.5}, {"label":"S", "x":2.75, "y":3.5}, {"label":"D", "x":3.75, "y":3.5}, {"label":"F", "x":4.75, "y":3.5}, {"label":"G", "x":5.75, "y":3.5}, {"label":"H", "x":6.75, "y":3.5}, {"label":"J", "x":7.75, "y":3.5}, {"label":"K", "x":8.75, "y":3.5}, {"label":"L", "x":9.75, "y":3.5}, {"label":":", "x":10.75, "y":3.5}, {"label":"\"", "x":11.75, "y":3.5}, {"x":12.75, "y":3.5}, {"label":"Enter", "x":13.75, "y":3.5, "w":1.25}, {"label":"Shift", "x":0, "y":4.5, "w":1.25}, {"x":1.25, "y":4.5}, {"label":"Z", "x":2.25, "y":4.5}, {"label":"X", "x":3.25, "y":4.5}, {"label":"C", "x":4.25, "y":4.5}, {"label":"V", "x":5.25, "y":4.5}, {"label":"B", "x":6.25, "y":4.5}, {"label":"N", "x":7.25, "y":4.5}, {"label":"M", "x":8.25, "y":4.5}, {"label":"<", "x":9.25, "y":4.5}, {"label":">", "x":10.25, "y":4.5}, {"label":"?", "x":11.25, "y":4.5}, {"label":"Shift", "x":12.25, "y":4.5, "w":1.75}, {"x":14, "y":4.5}, {"label":"\u2191", "x":16.25, "y":4.5}, {"label":"Ctrl", "x":0, "y":5.5, "w":1.25}, {"label":"Win", "x":1.25, "y":5.5, "w":1.25}, {"label":"Alt", "x":2.5, "y":5.5, "w":1.25}, {"x":3.75, "y":5.5, "w":6.25}, {"label":"Alt", "x":10, "y":5.5, "w":1.25}, {"label":"Win", "x":11.25, "y":5.5, "w":1.25}, {"label":"Menu", "x":12.5, "y":5.5, "w":1.25}, {"label":"Ctrl", "x":13.75, "y":5.5, "w":1.25}, {"label":"\u2190", "x":15.25, "y":5.5}, {"label":"\u2193", "x":16.25, "y":5.5}, {"label":"\u2192", "x":17.25, "y":5.5}] | |||
} | |||
} | |||
} |
@ -0,0 +1,90 @@ | |||
/* Copyright 2018 Josh Hinnebusch | |||
* | |||
* This program is free software: you can redistribute it and/or modify | |||
* it under the terms of the GNU General Public License as published by | |||
* the Free Software Foundation, either version 2 of the License, or | |||
* (at your option) any later version. | |||
* | |||
* This program is distributed in the hope that it will be useful, | |||
* but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |||
* GNU General Public License for more details. | |||
* | |||
* You should have received a copy of the GNU General Public License | |||
* along with this program. If not, see <http://www.gnu.org/licenses/>. | |||
*/ | |||
#pragma once | |||
#include "quantum.h" | |||
// This a shortcut to help you visually see your layout. | |||
// The following is an example using the Planck MIT layout | |||
// The first section contains all of the arguments | |||
// The second converts the arguments into a two-dimensional array | |||
#define LAYOUT_all(\ | |||
K000, K001, K011, K002, K012, K003, K013, K004, K014, K015, K006, K016, K007, K017, K008, K018, \ | |||
K020, K030, K021, K031, K022, K032, K023, K033, K024, K034, K025, K035, K026, K036, K027, K037, K028, K038, \ | |||
K040, K050, K041, K051, K042, K052, K043, K053, K044, K054, K045, K055, K046, K056, K057, K048, K058, \ | |||
K060, K070, K061, K071, K062, K072, K063, K073, K064, K074, K065, K075, K066, K076, \ | |||
K080, K090, K081, K091, K082, K092, K083, K093, K084, K094, K085, K095, K086, K096, K088, \ | |||
K100, K110, K101, K113, K105, K115, K106, K116, K117, K108, K118 \ | |||
) { \ | |||
{ K000, K001, K002, K003, K004, KC_NO, K006, K007, K008 }, \ | |||
{ KC_NO, K011, K012, K013, K014, K015, K016, K017, K018 }, \ | |||
{ K020, K021, K022, K023, K024, K025, K026, K027, K028 }, \ | |||
{ K030, K031, K032, K033, K034, K035, K036, K037, K038 }, \ | |||
{ K040, K041, K042, K043, K044, K045, K046, KC_NO, K048 }, \ | |||
{ K050, K051, K052, K053, K054, K055, K056, K057, K058 }, \ | |||
{ K060, K061, K062, K063, K064, K065, K066, KC_NO, KC_NO }, \ | |||
{ K070, K071, K072, K073, K074, K075, K076, KC_NO, KC_NO }, \ | |||
{ K080, K081, K082, K083, K084, K085, K086, KC_NO, K088 }, \ | |||
{ K090, K091, K092, K093, K094, K095, K096, KC_NO, KC_NO }, \ | |||
{ K100, K101, KC_NO, KC_NO, KC_NO, K105, K106, KC_NO, K108 }, \ | |||
{ K110, KC_NO, KC_NO, K113, KC_NO, K115, K116, K117, K118 } \ | |||
} | |||
#define LAYOUT_tkl_ansi(\ | |||
K000, K001, K011, K002, K012, K003, K013, K004, K014, K015, K006, K016, K007, K017, K008, K018, \ | |||
K020, K030, K021, K031, K022, K032, K023, K033, K024, K034, K025, K035, K026, K027, K037, K028, K038, \ | |||
K040, K050, K041, K051, K042, K052, K043, K053, K044, K054, K045, K055, K046, K056, K057, K048, K058, \ | |||
K060, K070, K061, K071, K062, K072, K063, K073, K064, K074, K065, K075, K076, \ | |||
K080, K081, K091, K082, K092, K083, K093, K084, K094, K085, K095, K086, K088, \ | |||
K100, K110, K101, K113, K105, K115, K106, K116, K117, K108, K118 \ | |||
) { \ | |||
{ K000, K001, K002, K003, K004, KC_NO, K006, K007, K008 }, \ | |||
{ KC_NO, K011, K012, K013, K014, K015, K016, K017, K018 }, \ | |||
{ K020, K021, K022, K023, K024, K025, K026, K027, K028 }, \ | |||
{ K030, K031, K032, K033, K034, K035, KC_NO, K037, K038 }, \ | |||
{ K040, K041, K042, K043, K044, K045, K046, KC_NO, K048 }, \ | |||
{ K050, K051, K052, K053, K054, K055, K056, K057, K058 }, \ | |||
{ K060, K061, K062, K063, K064, K065, KC_NO, KC_NO, KC_NO }, \ | |||
{ K070, K071, K072, K073, K074, K075, K076, KC_NO, KC_NO }, \ | |||
{ K080, K081, K082, K083, K084, K085, K086, KC_NO, K088 }, \ | |||
{KC_NO, K091, K092, K093, K094, K095, KC_NO, KC_NO, KC_NO }, \ | |||
{ K100, K101, KC_NO, KC_NO, KC_NO, K105, K106, KC_NO, K108 }, \ | |||
{ K110, KC_NO, KC_NO, K113, KC_NO, K115, K116, K117, K118 } \ | |||
} | |||
#define LAYOUT_tkl_ansi_wkl(\ | |||
K000, K001, K011, K002, K012, K003, K013, K004, K014, K015, K006, K016, K007, K017, K008, K018, \ | |||
K020, K030, K021, K031, K022, K032, K023, K033, K024, K034, K025, K035, K026, K027, K037, K028, K038, \ | |||
K040, K050, K041, K051, K042, K052, K043, K053, K044, K054, K045, K055, K046, K056, K057, K048, K058, \ | |||
K060, K070, K061, K071, K062, K072, K063, K073, K064, K074, K065, K075, K076, \ | |||
K080, K081, K091, K082, K092, K083, K093, K084, K094, K085, K095, K086, K088, \ | |||
K100, K101, K113, K115, K116, K117, K108, K118 \ | |||
) { \ | |||
{ K000, K001, K002, K003, K004, KC_NO, K006, K007, K008 }, \ | |||
{ KC_NO, K011, K012, K013, K014, K015, K016, K017, K018 }, \ | |||
{ K020, K021, K022, K023, K024, K025, K026, K027, K028 }, \ | |||
{ K030, K031, K032, K033, K034, K035, KC_NO, K037, K038 }, \ | |||
{ K040, K041, K042, K043, K044, K045, K046, KC_NO, K048 }, \ | |||
{ K050, K051, K052, K053, K054, K055, K056, K057, K058 }, \ | |||
{ K060, K061, K062, K063, K064, K065, KC_NO, KC_NO, KC_NO }, \ | |||
{ K070, K071, K072, K073, K074, K075, K076, KC_NO, KC_NO }, \ | |||
{ K080, K081, K082, K083, K084, K085, K086, KC_NO, K088 }, \ | |||
{KC_NO, K091, K092, K093, K094, K095, KC_NO, KC_NO, KC_NO }, \ | |||
{ K100, K101, KC_NO, KC_NO, KC_NO,KC_NO, KC_NO, KC_NO, K108 }, \ | |||
{KC_NO, KC_NO, KC_NO, K113, KC_NO, K115, K116, K117, K118 } \ | |||
} | |||
@ -0,0 +1,20 @@ | |||
{ | |||
"keyboard_name": "h87a", | |||
"url": "", | |||
"maintainer": "hineybush", | |||
"width": 18.25, | |||
"height": 6.5, | |||
"layouts": { | |||
"LAYOUT_all": { | |||
"layout": [{"label":"Esc", "x":0, "y":0}, {"label":"F1", "x":2, "y":0}, {"label":"F2", "x":3, "y":0}, {"label":"F3", "x":4, "y":0}, {"label":"F4", "x":5, "y":0}, {"label":"F5", "x":6.5, "y":0}, {"label":"F6", "x":7.5, "y":0}, {"label":"F7", "x":8.5, "y":0}, {"label":"F8", "x":9.5, "y":0}, {"label":"F9", "x":11, "y":0}, {"label":"F10", "x":12, "y":0}, {"label":"F11", "x":13, "y":0}, {"label":"F12", "x":14, "y":0}, {"label":"PrtSc", "x":15.25, "y":0}, {"label":"Scroll Lock", "x":16.25, "y":0}, {"label":"Pause", "x":17.25, "y":0}, {"label":"~", "x":0, "y":1.5}, {"label":"!", "x":1, "y":1.5}, {"label":"@", "x":2, "y":1.5}, {"label":"#", "x":3, "y":1.5}, {"label":"$", "x":4, "y":1.5}, {"label":"%", "x":5, "y":1.5}, {"label":"^", "x":6, "y":1.5}, {"label":"&", "x":7, "y":1.5}, {"label":"*", "x":8, "y":1.5}, {"label":"(", "x":9, "y":1.5}, {"label":")", "x":10, "y":1.5}, {"label":"_", "x":11, "y":1.5}, {"label":"+", "x":12, "y":1.5}, {"x":13, "y":1.5}, {"label":"Bksp", "x":14, "y":1.5}, {"label":"Insert", "x":15.25, "y":1.5}, {"label":"Home", "x":16.25, "y":1.5}, {"label":"PgUp", "x":17.25, "y":1.5}, {"label":"Tab", "x":0, "y":2.5, "w":1.5}, {"label":"Q", "x":1.5, "y":2.5}, {"label":"W", "x":2.5, "y":2.5}, {"label":"E", "x":3.5, "y":2.5}, {"label":"R", "x":4.5, "y":2.5}, {"label":"T", "x":5.5, "y":2.5}, {"label":"Y", "x":6.5, "y":2.5}, {"label":"U", "x":7.5, "y":2.5}, {"label":"I", "x":8.5, "y":2.5}, {"label":"O", "x":9.5, "y":2.5}, {"label":"P", "x":10.5, "y":2.5}, {"label":"{", "x":11.5, "y":2.5}, {"label":"}", "x":12.5, "y":2.5}, {"label":"|", "x":13.5, "y":2.5, "w":1.5}, {"label":"Delete", "x":15.25, "y":2.5}, {"label":"End", "x":16.25, "y":2.5}, {"label":"PgDn", "x":17.25, "y":2.5}, {"label":"Caps Lock", "x":0, "y":3.5, "w":1.75}, {"label":"A", "x":1.75, "y":3.5}, {"label":"S", "x":2.75, "y":3.5}, {"label":"D", "x":3.75, "y":3.5}, {"label":"F", "x":4.75, "y":3.5}, {"label":"G", "x":5.75, "y":3.5}, {"label":"H", "x":6.75, "y":3.5}, {"label":"J", "x":7.75, "y":3.5}, {"label":"K", "x":8.75, "y":3.5}, {"label":"L", "x":9.75, "y":3.5}, {"label":":", "x":10.75, "y":3.5}, {"label":"\"", "x":11.75, "y":3.5}, {"x":12.75, "y":3.5}, {"label":"Enter", "x":13.75, "y":3.5, "w":1.25}, {"label":"Shift", "x":0, "y":4.5, "w":1.25}, {"x":1.25, "y":4.5}, {"label":"Z", "x":2.25, "y":4.5}, {"label":"X", "x":3.25, "y":4.5}, {"label":"C", "x":4.25, "y":4.5}, {"label":"V", "x":5.25, "y":4.5}, {"label":"B", "x":6.25, "y":4.5}, {"label":"N", "x":7.25, "y":4.5}, {"label":"M", "x":8.25, "y":4.5}, {"label":"<", "x":9.25, "y":4.5}, {"label":">", "x":10.25, "y":4.5}, {"label":"?", "x":11.25, "y":4.5}, {"label":"Shift", "x":12.25, "y":4.5, "w":1.75}, {"x":14, "y":4.5}, {"label":"\u2191", "x":16.25, "y":4.5}, {"label":"Ctrl", "x":0, "y":5.5, "w":1.25}, {"label":"Win", "x":1.25, "y":5.5, "w":1.25}, {"label":"Alt", "x":2.5, "y":5.5, "w":1.25}, {"x":3.75, "y":5.5, "w":6.25}, {"label":"Alt", "x":10, "y":5.5, "w":1.25}, {"label":"Win", "x":11.25, "y":5.5, "w":1.25}, {"label":"Menu", "x":12.5, "y":5.5, "w":1.25}, {"label":"Ctrl", "x":13.75, "y":5.5, "w":1.25}, {"label":"\u2190", "x":15.25, "y":5.5}, {"label":"\u2193", "x":16.25, "y":5.5}, {"label":"\u2192", "x":17.25, "y":5.5}] | |||
}, | |||
"LAYOUT_tkl_ansi": { | |||
"layout": [{"label":"Esc", "x":0, "y":0}, {"label":"F1", "x":2, "y":0}, {"label":"F2", "x":3, "y":0}, {"label":"F3", "x":4, "y":0}, {"label":"F4", "x":5, "y":0}, {"label":"F5", "x":6.5, "y":0}, {"label":"F6", "x":7.5, "y":0}, {"label":"F7", "x":8.5, "y":0}, {"label":"F8", "x":9.5, "y":0}, {"label":"F9", "x":11, "y":0}, {"label":"F10", "x":12, "y":0}, {"label":"F11", "x":13, "y":0}, {"label":"F12", "x":14, "y":0}, {"label":"PrtSc", "x":15.25, "y":0}, {"label":"Scroll Lock", "x":16.25, "y":0}, {"label":"Pause", "x":17.25, "y":0}, {"label":"~", "x":0, "y":1.5}, {"label":"!", "x":1, "y":1.5}, {"label":"@", "x":2, "y":1.5}, {"label":"#", "x":3, "y":1.5}, {"label":"$", "x":4, "y":1.5}, {"label":"%", "x":5, "y":1.5}, {"label":"^", "x":6, "y":1.5}, {"label":"&", "x":7, "y":1.5}, {"label":"*", "x":8, "y":1.5}, {"label":"(", "x":9, "y":1.5}, {"label":")", "x":10, "y":1.5}, {"label":"_", "x":11, "y":1.5}, {"label":"+", "x":12, "y":1.5}, {"label":"Bksp", "x":13, "y":1.5, "w":2}, {"label":"Insert", "x":15.25, "y":1.5}, {"label":"Home", "x":16.25, "y":1.5}, {"label":"PgUp", "x":17.25, "y":1.5}, {"label":"Tab", "x":0, "y":2.5, "w":1.5}, {"label":"Q", "x":1.5, "y":2.5}, {"label":"W", "x":2.5, "y":2.5}, {"label":"E", "x":3.5, "y":2.5}, {"label":"R", "x":4.5, "y":2.5}, {"label":"T", "x":5.5, "y":2.5}, {"label":"Y", "x":6.5, "y":2.5}, {"label":"U", "x":7.5, "y":2.5}, {"label":"I", "x":8.5, "y":2.5}, {"label":"O", "x":9.5, "y":2.5}, {"label":"P", "x":10.5, "y":2.5}, {"label":"{", "x":11.5, "y":2.5}, {"label":"}", "x":12.5, "y":2.5}, {"label":"|", "x":13.5, "y":2.5, "w":1.5}, {"label":"Delete", "x":15.25, "y":2.5}, {"label":"End", "x":16.25, "y":2.5}, {"label":"PgDn", "x":17.25, "y":2.5}, {"label":"Caps Lock", "x":0, "y":3.5, "w":1.75}, {"label":"A", "x":1.75, "y":3.5}, {"label":"S", "x":2.75, "y":3.5}, {"label":"D", "x":3.75, "y":3.5}, {"label":"F", "x":4.75, "y":3.5}, {"label":"G", "x":5.75, "y":3.5}, {"label":"H", "x":6.75, "y":3.5}, {"label":"J", "x":7.75, "y":3.5}, {"label":"K", "x":8.75, "y":3.5}, {"label":"L", "x":9.75, "y":3.5}, {"label":":", "x":10.75, "y":3.5}, {"label":"\"", "x":11.75, "y":3.5}, {"label":"Enter", "x":12.75, "y":3.5, "w":2.25}, {"label":"Shift", "x":0, "y":4.5, "w":2.25}, {"label":"Z", "x":2.25, "y":4.5}, {"label":"X", "x":3.25, "y":4.5}, {"label":"C", "x":4.25, "y":4.5}, {"label":"V", "x":5.25, "y":4.5}, {"label":"B", "x":6.25, "y":4.5}, {"label":"N", "x":7.25, "y":4.5}, {"label":"M", "x":8.25, "y":4.5}, {"label":"<", "x":9.25, "y":4.5}, {"label":">", "x":10.25, "y":4.5}, {"label":"?", "x":11.25, "y":4.5}, {"label":"Shift", "x":12.25, "y":4.5, "w":2.75}, {"label":"\u2191", "x":16.25, "y":4.5}, {"label":"Ctrl", "x":0, "y":5.5, "w":1.25}, {"label":"Win", "x":1.25, "y":5.5, "w":1.25}, {"label":"Alt", "x":2.5, "y":5.5, "w":1.25}, {"x":3.75, "y":5.5, "w":6.25}, {"label":"Alt", "x":10, "y":5.5, "w":1.25}, {"label":"Win", "x":11.25, "y":5.5, "w":1.25}, {"label":"Menu", "x":12.5, "y":5.5, "w":1.25}, {"label":"Ctrl", "x":13.75, "y":5.5, "w":1.25}, {"label":"\u2190", "x":15.25, "y":5.5}, {"label":"\u2193", "x":16.25, "y":5.5}, {"label":"\u2192", "x":17.25, "y":5.5}] | |||
}, | |||
"LAYOUT_tkl_ansi_wkl": { | |||
"layout": [{"label":"Esc", "x":0, "y":0}, {"label":"F1", "x":2, "y":0}, {"label":"F2", "x":3, "y":0}, {"label":"F3", "x":4, "y":0}, {"label":"F4", "x":5, "y":0}, {"label":"F5", "x":6.5, "y":0}, {"label":"F6", "x":7.5, "y":0}, {"label":"F7", "x":8.5, "y":0}, {"label":"F8", "x":9.5, "y":0}, {"label":"F9", "x":11, "y":0}, {"label":"F10", "x":12, "y":0}, {"label":"F11", "x":13, "y":0}, {"label":"F12", "x":14, "y":0}, {"label":"PrtSc", "x":15.25, "y":0}, {"label":"Scroll Lock", "x":16.25, "y":0}, {"label":"Pause", "x":17.25, "y":0}, {"label":"~", "x":0, "y":1.5}, {"label":"!", "x":1, "y":1.5}, {"label":"@", "x":2, "y":1.5}, {"label":"#", "x":3, "y":1.5}, {"label":"$", "x":4, "y":1.5}, {"label":"%", "x":5, "y":1.5}, {"label":"^", "x":6, "y":1.5}, {"label":"&", "x":7, "y":1.5}, {"label":"*", "x":8, "y":1.5}, {"label":"(", "x":9, "y":1.5}, {"label":")", "x":10, "y":1.5}, {"label":"_", "x":11, "y":1.5}, {"label":"+", "x":12, "y":1.5}, {"label":"Bksp", "x":13, "y":1.5, "w":2}, {"label":"Insert", "x":15.25, "y":1.5}, {"label":"Home", "x":16.25, "y":1.5}, {"label":"PgUp", "x":17.25, "y":1.5}, {"label":"Tab", "x":0, "y":2.5, "w":1.5}, {"label":"Q", "x":1.5, "y":2.5}, {"label":"W", "x":2.5, "y":2.5}, {"label":"E", "x":3.5, "y":2.5}, {"label":"R", "x":4.5, "y":2.5}, {"label":"T", "x":5.5, "y":2.5}, {"label":"Y", "x":6.5, "y":2.5}, {"label":"U", "x":7.5, "y":2.5}, {"label":"I", "x":8.5, "y":2.5}, {"label":"O", "x":9.5, "y":2.5}, {"label":"P", "x":10.5, "y":2.5}, {"label":"{", "x":11.5, "y":2.5}, {"label":"}", "x":12.5, "y":2.5}, {"label":"|", "x":13.5, "y":2.5, "w":1.5}, {"label":"Delete", "x":15.25, "y":2.5}, {"label":"End", "x":16.25, "y":2.5}, {"label":"PgDn", "x":17.25, "y":2.5}, {"label":"Caps Lock", "x":0, "y":3.5, "w":1.75}, {"label":"A", "x":1.75, "y":3.5}, {"label":"S", "x":2.75, "y":3.5}, {"label":"D", "x":3.75, "y":3.5}, {"label":"F", "x":4.75, "y":3.5}, {"label":"G", "x":5.75, "y":3.5}, {"label":"H", "x":6.75, "y":3.5}, {"label":"J", "x":7.75, "y":3.5}, {"label":"K", "x":8.75, "y":3.5}, {"label":"L", "x":9.75, "y":3.5}, {"label":":", "x":10.75, "y":3.5}, {"label":"\"", "x":11.75, "y":3.5}, {"label":"Enter", "x":12.75, "y":3.5, "w":2.25}, {"label":"Shift", "x":0, "y":4.5, "w":2.25}, {"label":"Z", "x":2.25, "y":4.5}, {"label":"X", "x":3.25, "y":4.5}, {"label":"C", "x":4.25, "y":4.5}, {"label":"V", "x":5.25, "y":4.5}, {"label":"B", "x":6.25, "y":4.5}, {"label":"N", "x":7.25, "y":4.5}, {"label":"M", "x":8.25, "y":4.5}, {"label":"<", "x":9.25, "y":4.5}, {"label":">", "x":10.25, "y":4.5}, {"label":"?", "x":11.25, "y":4.5}, {"label":"Shift", "x":12.25, "y":4.5, "w":2.75}, {"label":"\u2191", "x":16.25, "y":4.5}, {"label":"Ctrl", "x":0, "y":5.5, "w":1.5}, {"label":"Alt", "x":2.5, "y":5.5, "w":1.5}, {"x":4, "y":5.5, "w":7}, {"label":"Alt", "x":11, "y":5.5, "w":1.5}, {"label":"Ctrl", "x":13.5, "y":5.5, "w":1.5}, {"label":"\u2190", "x":15.25, "y":5.5}, {"label":"\u2193", "x":16.25, "y":5.5}, {"label":"\u2192", "x":17.25, "y":5.5}] | |||
} | |||
} | |||
} | |||
@ -0,0 +1,21 @@ | |||
/* Copyright 2018 Josh Hinnebusch | |||
* | |||
* This program is free software: you can redistribute it and/or modify | |||
* it under the terms of the GNU General Public License as published by | |||
* the Free Software Foundation, either version 2 of the License, or | |||
* (at your option) any later version. | |||
* | |||
* This program is distributed in the hope that it will be useful, | |||
* but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |||
* GNU General Public License for more details. | |||
* | |||
* You should have received a copy of the GNU General Public License | |||
* along with this program. If not, see <http://www.gnu.org/licenses/>. | |||
*/ | |||
#pragma once | |||
// place overrides here | |||