1
0
Fork 0

[Keymap] update my keymap for Infinity Ergodox (#6864)

* 🎉 Building simple flasher

* 🎉 Flashing works

* 🎨 Cleaning up

* 🐛 Being more specific with board identity

* 🐛 Flashing correct keymap

* 🎉 Adding keymap

*  Updating keymap

* 🚨 RGB

*  Revert "🚨 RGB"

This reverts commit 9ceabfb267f8daedaad929231229c703abc12ec4.

*  Improvements to flasher

*  Layout tweaks

* 💄 Messing around with LCD

* 💄 Enabling LCD backlight matching

* 🔧 Updating layout

* 🐛 Fixing console logging

* 🎨 Cleaning up indentation

* 🔧 Adding editorconfig

*  Adding game layer

* 💄 Changing numpad layout

* 🔥 redoing entire layout

It's now more similar to the Planck default layout

*  add workman and dvorak layouts

* 🐛 fix numpad

* 🐛 fix layer orders

* 🐛 fix layer toggling

* 🐛 fix tri-layer switching

* 🐛 fix LCD colors for adjustment layers

* 🔥 remove old flasher project

* 🔥 remove simple_visualizer

* 💄 update LCD colors

* 📝 fix layout comments

* 💄  swapping 2u buttons

* 🔥🔧 removing editorconfig

* 🚨 using 2 spaces

* 📝 add README

*  Revert "💄 Enabling LCD backlight matching"

This reverts commit 51577903dfdc9fea5d33e9ab8cfa9b854e7ae19e.

*  Revert "💄 Messing around with LCD"

This reverts commit fdd9acdae514a3e0e4a7153225053680744980e5.

* 🐛 fix thumb inconsistency in QWERTY

* 🐛 fix media keys

*  add F# shortcuts to vertical 1.5u buttons

*  hold enter for RShift

*  hold for numpad

* 🎨 remove unnecessary breaks

* 🎨 reoganizing layers

*  add Colmak layer

* 🚧🔧 add basic config

*  use more standard numpad layout

* 💄 change layer orders

*  add caps lock on adjust layer

* 🔥 disable space cadet

* 📝 update README

* 🔨 use userspace config

* 🎨 clean up a bit

* 🐛 undefine tapping toggle from base config

* 🔨 rename LED functions

* 💩 someone commited Windows line endings

*  left hand thumb is space

* ♻️ extract layers def to new file

* 🔥 remove unnecessary hooks

* 💄 set LCD text and color by layer

* 💄 update keymap

removing layer buttons that I don't really use

*  set backlight to full brightness on boot

* 🔥 remove unnecessary includes
This commit is contained in:
Louis Orleans 2019-10-04 20:32:52 -07:00 committed by noroadsleft
parent 93bce83255
commit c5ffd182c8
4 changed files with 262 additions and 431 deletions

View file

@ -1,20 +1,6 @@
#include QMK_KEYBOARD_H #include QMK_KEYBOARD_H
#include "debug.h"
#include "action_layer.h"
#include "version.h" #include "version.h"
#include "layers.h"
enum custom_layers {
_QWERTY,
_WORKMAN,
_DVORAK,
_COLEMAK,
_LOWER,
_RAISE,
_ADJUST,
_GAME,
_MOUSE,
_NUM,
};
enum custom_keycodes { enum custom_keycodes {
QWERTY = SAFE_RANGE, QWERTY = SAFE_RANGE,
@ -39,39 +25,39 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
* | Tab | Q | W | E | R | T | [{ | | ]} | Y | U | I | O | P | BSPC | * | Tab | Q | W | E | R | T | [{ | | ]} | Y | U | I | O | P | BSPC |
* |--------+-----+-----+-----+-----+-----| | | |-----+-----+-----+-----+-----+--------| * |--------+-----+-----+-----+-----+-----| | | |-----+-----+-----+-----+-----+--------|
* | ESC | A | S | D | F | G |------| |------| H | J | K | L | ; | ' | * | ESC | A | S | D | F | G |------| |------| H | J | K | L | ; | ' |
* |--------+-----+-----+-----+-----+-----| L1 | | L1 |-----+-----+-----+-----+-----+--------| * |--------+-----+-----+-----+-----+-----| | | |-----+-----+-----+-----+-----+--------|
* | LShift | Z | X | C | V | B | | | | N | M | , | . | / | Enter | * | LShift | Z | X | C | V | B | | | | N | M | , | . | / | Enter |
* `--------+-----+-----+-----+-----+------------' `------------+-----+-----+-----+-----+--------' * `--------+-----+-----+-----+-----+------------' `------------+-----+-----+-----+-----+--------'
* | Num |Ctrl | Alt |LGUI |Lower| |Raise|Left |Down | Up |Right | * | Num |Ctrl | Alt |LGUI |Lower| |Raise|Left |Down | Up |Right |
* `------------------------------' `------------------------------' * `------------------------------' `------------------------------'
* ,------------. ,------------. * ,------------. ,------------.
* |Play |Mouse | | Num |Mouse| * |Play | | | |Play |
* ,----|-----|------| |------+-----+-----. * ,-----|-----|------| |------+-----+-----.
* | | | Alt | | Alt | | | * | | | Alt | | Alt | | |
* |BSPC|LOWER|------| |------|RAISE|Space| * |Space|LOWER|------| |------|RAISE|Space|
* | | | LGUI | | LGUI | | | * | | | LGUI | | LGUI | | |
* `-----------------' `------------------' * `------------------' `------------------'
*/ */
[_QWERTY] = LAYOUT_ergodox( [_QWERTY] = LAYOUT_ergodox(
// left hand // left hand
KC_GRV, KC_1, KC_2, KC_3, KC_4, KC_5, KC_ESC, KC_GRV, KC_1, KC_2, KC_3, KC_4, KC_5, KC_ESC,
KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_LBRACKET, KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_LBRACKET,
KC_ESC, KC_A, KC_S, KC_D, KC_F, KC_G, KC_ESC, KC_A, KC_S, KC_D, KC_F, KC_G,
KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_FN1, KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, _______,
TT(_NUM), KC_LCTL, KC_LALT, KC_LGUI, LOWER, TT(_NUM), KC_LCTL, KC_LALT, KC_LGUI, LOWER,
KC_MPLY, TG(_MOUSE), KC_MPLY, _______,
KC_LALT, KC_LALT,
KC_BSPACE, LOWER, KC_LGUI, KC_SPACE, LOWER, KC_LGUI,
// right hand // right hand
KC_ESC, KC_6, KC_7, KC_8, KC_9, KC_0, KC_DEL, KC_ESC, KC_6, KC_7, KC_8, KC_9, KC_0, KC_DEL,
KC_RBRACKET, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_BSPACE, KC_RBRACKET, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_BSPACE,
KC_H, KC_J, KC_K, KC_L, KC_SCOLON, KC_QUOTE, KC_H, KC_J, KC_K, KC_L, KC_SCOLON, KC_QUOTE,
KC_FN1, KC_N, KC_M, KC_COMM, KC_DOT, LT(_MOUSE, KC_SLSH), RSFT_T(KC_ENT), _______, KC_N, KC_M, KC_COMM, KC_DOT, LT(_MOUSE, KC_SLSH), RSFT_T(KC_ENT),
RAISE, KC_LEFT, KC_DOWN, KC_UP, KC_RIGHT, RAISE, KC_LEFT, KC_DOWN, KC_UP, KC_RIGHT,
TT(_NUM), TG(_MOUSE), _______, KC_MPLY,
KC_LALT, KC_LALT,
KC_LGUI, RAISE, KC_SPACE KC_LGUI, RAISE, KC_SPACE
), ),
@ -84,39 +70,39 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
* | Tab | Q | D | R | W | B | [{ | | ]} | J | F | U | P | ; | BSPC | * | Tab | Q | D | R | W | B | [{ | | ]} | J | F | U | P | ; | BSPC |
* |--------+-----+-----+-----+-----+-----| | | |-----+-----+-----+-----+-----+--------| * |--------+-----+-----+-----+-----+-----| | | |-----+-----+-----+-----+-----+--------|
* | ESC | A | S | H | T | G |------| |------| Y | N | E | O | I | ' | * | ESC | A | S | H | T | G |------| |------| Y | N | E | O | I | ' |
* |--------+-----+-----+-----+-----+-----| L1 | | L1 |-----+-----+-----+-----+-----+--------| * |--------+-----+-----+-----+-----+-----| | | |-----+-----+-----+-----+-----+--------|
* | LShift | Z | X | M | C | V | | | | K | L | , | . | / | Enter | * | LShift | Z | X | M | C | V | | | | K | L | , | . | / | Enter |
* `--------+-----+-----+-----+-----+------------' `------------+-----+-----+-----+-----+--------' * `--------+-----+-----+-----+-----+------------' `------------+-----+-----+-----+-----+--------'
* | Num |Ctrl | Alt |LGUI |Lower| |Raise|Left |Down | Up |Right | * | Num |Ctrl | Alt |LGUI |Lower| |Raise|Left |Down | Up |Right |
* `------------------------------' `------------------------------' * `------------------------------' `------------------------------'
* ,------------. ,------------. * ,------------. ,------------.
* |Play |Mouse | | Num |Mouse| * |Play | | | |Play |
* ,----|-----|------| |------+-----+-----. * ,-----|-----|------| |------+-----+-----.
* | | | Alt | | Alt | | | * | | | Alt | | Alt | | |
* |BSPC|LOWER|------| |------|RAISE|Space| * |Space|LOWER|------| |------|RAISE|Space|
* | | | LGUI | | LGUI | | | * | | | LGUI | | LGUI | | |
* `-----------------' `------------------' * `------------------' `------------------'
*/ */
[_WORKMAN] = LAYOUT_ergodox( [_WORKMAN] = LAYOUT_ergodox(
// left hand // left hand
KC_GRV, KC_1, KC_2, KC_3, KC_4, KC_5, KC_ESC, KC_GRV, KC_1, KC_2, KC_3, KC_4, KC_5, KC_ESC,
KC_TAB, KC_Q, KC_D, KC_R, KC_W, KC_B, KC_LBRACKET, KC_TAB, KC_Q, KC_D, KC_R, KC_W, KC_B, KC_LBRACKET,
KC_ESC, KC_A, KC_S, KC_H, KC_T, KC_G, KC_ESC, KC_A, KC_S, KC_H, KC_T, KC_G,
KC_LSFT, KC_Z, KC_X, KC_M, KC_C, KC_V, KC_FN1, KC_LSFT, KC_Z, KC_X, KC_M, KC_C, KC_V, _______,
TT(_NUM), KC_LCTL, KC_LALT, KC_LGUI, LOWER, TT(_NUM), KC_LCTL, KC_LALT, KC_LGUI, LOWER,
KC_MPLY, TG(_MOUSE), KC_MPLY, _______,
KC_LALT, KC_LALT,
KC_BSPACE, LOWER, KC_LGUI, KC_SPACE, LOWER, KC_LGUI,
// right hand // right hand
KC_ESC, KC_6, KC_7, KC_8, KC_9, KC_0, KC_DEL, KC_ESC, KC_6, KC_7, KC_8, KC_9, KC_0, KC_DEL,
KC_RBRACKET, KC_J, KC_F, KC_U, KC_P, KC_SCOLON, KC_BSPACE, KC_RBRACKET, KC_J, KC_F, KC_U, KC_P, KC_SCOLON, KC_BSPACE,
KC_Y, KC_N, KC_E, KC_O, KC_I, KC_QUOTE, KC_Y, KC_N, KC_E, KC_O, KC_I, KC_QUOTE,
KC_FN1, KC_K, KC_L, KC_COMM, KC_DOT, LT(_MOUSE, KC_SLSH), RSFT_T(KC_ENT), _______, KC_K, KC_L, KC_COMM, KC_DOT, LT(_MOUSE, KC_SLSH), RSFT_T(KC_ENT),
RAISE, KC_LEFT, KC_DOWN, KC_UP, KC_RIGHT, RAISE, KC_LEFT, KC_DOWN, KC_UP, KC_RIGHT,
TT(_NUM), TG(_MOUSE), _______, KC_MPLY,
KC_LALT, KC_LALT,
KC_LGUI, RAISE, KC_SPACE KC_LGUI, RAISE, KC_SPACE
), ),
@ -129,39 +115,39 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
* | Tab | ' | , | . | P | Y | [{ | | ]} | F | G | C | R | L | BSPC | * | Tab | ' | , | . | P | Y | [{ | | ]} | F | G | C | R | L | BSPC |
* |--------+-----+-----+-----+-----+-----| | | |-----+-----+-----+-----+-----+--------| * |--------+-----+-----+-----+-----+-----| | | |-----+-----+-----+-----+-----+--------|
* | ESC | A | O | E | U | I |------| |------| D | H | T | N | S | / | * | ESC | A | O | E | U | I |------| |------| D | H | T | N | S | / |
* |--------+-----+-----+-----+-----+-----| L1 | | L1 |-----+-----+-----+-----+-----+--------| * |--------+-----+-----+-----+-----+-----| | | |-----+-----+-----+-----+-----+--------|
* | LShift | ; | Q | J | K | X | | | | B | M | W | V | Z | Enter | * | LShift | ; | Q | J | K | X | | | | B | M | W | V | Z | Enter |
* `--------+-----+-----+-----+-----+------------' `------------+-----+-----+-----+-----+--------' * `--------+-----+-----+-----+-----+------------' `------------+-----+-----+-----+-----+--------'
* | Num |Ctrl | Alt |LGUI |Lower| |Raise|Left |Down | Up |Right | * | Num |Ctrl | Alt |LGUI |Lower| |Raise|Left |Down | Up |Right |
* `------------------------------' `------------------------------' * `------------------------------' `------------------------------'
* ,------------. ,------------. * ,------------. ,------------.
* |Play |Mouse | | Num |Mouse| * |Play | | | |Play |
* ,----|-----|------| |------+-----+-----. * ,-----|-----|------| |------+-----+-----.
* | | | Alt | | Alt | | | * | | | Alt | | Alt | | |
* |BSPC|LOWER|------| |------|RAISE|Space| * |Space|LOWER|------| |------|RAISE|Space|
* | | | LGUI | | LGUI | | | * | | | LGUI | | LGUI | | |
* `-----------------' `------------------' * `------------------' `------------------'
*/ */
[_DVORAK] = LAYOUT_ergodox( [_DVORAK] = LAYOUT_ergodox(
// left hand // left hand
KC_GRV, KC_1, KC_2, KC_3, KC_4, KC_5, KC_ESC, KC_GRV, KC_1, KC_2, KC_3, KC_4, KC_5, KC_ESC,
KC_TAB, KC_QUOT, KC_COMM, KC_DOT, KC_P, KC_Y, KC_LBRACKET, KC_TAB, KC_QUOT, KC_COMM, KC_DOT, KC_P, KC_Y, KC_LBRACKET,
KC_ESC, KC_A, KC_O, KC_E, KC_U, KC_I, KC_ESC, KC_A, KC_O, KC_E, KC_U, KC_I,
KC_LSFT, KC_SCOLON, KC_Q, KC_J, KC_K, KC_X, KC_FN1, KC_LSFT, KC_SCOLON, KC_Q, KC_J, KC_K, KC_X, _______,
TT(_NUM), KC_LCTL, KC_LALT, KC_LGUI, LOWER, TT(_NUM), KC_LCTL, KC_LALT, KC_LGUI, LOWER,
KC_MPLY, TG(_MOUSE), KC_MPLY, _______,
KC_LALT, KC_LALT,
KC_BSPACE, LOWER, KC_LGUI, KC_SPACE, LOWER, KC_LGUI,
// right hand // right hand
KC_ESC, KC_6, KC_7, KC_8, KC_9, KC_0, KC_DEL, KC_ESC, KC_6, KC_7, KC_8, KC_9, KC_0, KC_DEL,
KC_RBRACKET, KC_F, KC_G, KC_C, KC_R, KC_L, KC_BSPACE, KC_RBRACKET, KC_F, KC_G, KC_C, KC_R, KC_L, KC_BSPACE,
KC_D, KC_H, KC_T, KC_N, KC_S, LT(MOUSE, KC_SLSH), KC_D, KC_H, KC_T, KC_N, KC_S, LT(MOUSE, KC_SLSH),
KC_FN1, KC_B, KC_M, KC_W, KC_V, KC_Z, RSFT_T(KC_ENT), _______, KC_B, KC_M, KC_W, KC_V, KC_Z, RSFT_T(KC_ENT),
RAISE, KC_LEFT, KC_DOWN, KC_UP, KC_RIGHT, RAISE, KC_LEFT, KC_DOWN, KC_UP, KC_RIGHT,
TT(_NUM), TG(_MOUSE), _______, KC_MPLY,
KC_LALT, KC_LALT,
KC_LGUI, RAISE, KC_SPACE KC_LGUI, RAISE, KC_SPACE
), ),
@ -174,39 +160,39 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
* | Tab | Q | W | F | P | G | [{ | | ]} | J | L | U | Y | ; | BSPC | * | Tab | Q | W | F | P | G | [{ | | ]} | J | L | U | Y | ; | BSPC |
* |--------+-----+-----+-----+-----+-----| | | |-----+-----+-----+-----+-----+--------| * |--------+-----+-----+-----+-----+-----| | | |-----+-----+-----+-----+-----+--------|
* | ESC | A | R | S | T | D |------| |------| H | N | E | I | O | ' | * | ESC | A | R | S | T | D |------| |------| H | N | E | I | O | ' |
* |--------+-----+-----+-----+-----+-----| L1 | | L1 |-----+-----+-----+-----+-----+--------| * |--------+-----+-----+-----+-----+-----| | | |-----+-----+-----+-----+-----+--------|
* | LShift | Z | X | C | V | B | | | | K | M | , | . | / | Enter | * | LShift | Z | X | C | V | B | | | | K | M | , | . | / | Enter |
* `--------+-----+-----+-----+-----+------------' `------------+-----+-----+-----+-----+--------' * `--------+-----+-----+-----+-----+------------' `------------+-----+-----+-----+-----+--------'
* | Num |Ctrl | Alt |LGUI |Lower| |Raise|Left |Down | Up |Right | * | Num |Ctrl | Alt |LGUI |Lower| |Raise|Left |Down | Up |Right |
* `------------------------------' `------------------------------' * `------------------------------' `------------------------------'
* ,------------. ,------------. * ,------------. ,------------.
* |Play |Mouse | | Num |Mouse| * |Play | | | |Play |
* ,----|-----|------| |------+-----+-----. * ,-----|-----|------| |------+-----+-----.
* | | | Alt | | Alt | | | * | | | Alt | | Alt | | |
* |BSPC|LOWER|------| |------|RAISE|Space| * |Space|LOWER|------| |------|RAISE|Space|
* | | | LGUI | | LGUI | | | * | | | LGUI | | LGUI | | |
* `-----------------' `------------------' * `------------------' `------------------'
*/ */
[_COLEMAK] = LAYOUT_ergodox( [_COLEMAK] = LAYOUT_ergodox(
// left hand // left hand
KC_GRV, KC_1, KC_2, KC_3, KC_4, KC_5, KC_ESC, KC_GRV, KC_1, KC_2, KC_3, KC_4, KC_5, KC_ESC,
KC_TAB, KC_Q, KC_W, KC_F, KC_P, KC_G, KC_LBRACKET, KC_TAB, KC_Q, KC_W, KC_F, KC_P, KC_G, KC_LBRACKET,
KC_ESC, KC_A, KC_R, KC_S, KC_T, KC_D, KC_ESC, KC_A, KC_R, KC_S, KC_T, KC_D,
KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_FN1, KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, _______,
TT(_NUM), KC_LCTL, KC_LALT, KC_LGUI, LOWER, TT(_NUM), KC_LCTL, KC_LALT, KC_LGUI, LOWER,
KC_MPLY, TG(_MOUSE), KC_MPLY, _______,
KC_LALT, KC_LALT,
KC_BSPACE, LOWER, KC_LGUI, KC_SPACE, LOWER, KC_LGUI,
// right hand // right hand
KC_ESC, KC_6, KC_7, KC_8, KC_9, KC_0, KC_DEL, KC_ESC, KC_6, KC_7, KC_8, KC_9, KC_0, KC_DEL,
KC_RBRACKET, KC_J, KC_L, KC_U, KC_Y, KC_SCOLON, KC_BSPACE, KC_RBRACKET, KC_J, KC_L, KC_U, KC_Y, KC_SCOLON, KC_BSPACE,
KC_H, KC_N, KC_E, KC_I, KC_O, KC_QUOTE, KC_H, KC_N, KC_E, KC_I, KC_O, KC_QUOTE,
KC_FN1, KC_K, KC_M, KC_COMM, KC_DOT, LT(_MOUSE, KC_SLSH), RSFT_T(KC_ENT), _______, KC_K, KC_M, KC_COMM, KC_DOT, LT(_MOUSE, KC_SLSH), RSFT_T(KC_ENT),
RAISE, KC_LEFT, KC_DOWN, KC_UP, KC_RIGHT, RAISE, KC_LEFT, KC_DOWN, KC_UP, KC_RIGHT,
TT(_NUM), TG(_MOUSE), _______, KC_MPLY,
KC_LALT, KC_LALT,
KC_LGUI, RAISE, KC_SPACE KC_LGUI, RAISE, KC_SPACE
), ),
@ -216,19 +202,19 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
* ,---------------------------------------------------. ,--------------------------------------------------. * ,---------------------------------------------------. ,--------------------------------------------------.
* | Version | F1 | F2 | F3 | F4 | F5 | F11 | | F12 | F6 | F7 | F8 | F9 | F10 | | * | Version | F1 | F2 | F3 | F4 | F5 | F11 | | F12 | F6 | F7 | F8 | F9 | F10 | |
* |---------+------+------+------+------+------+------| |------+------+------+------+------+------+--------| * |---------+------+------+------+------+------+------| |------+------+------+------+------+------+--------|
* | ~ | ! | @ | # | $ | % | | | | ^ | & | * | ( | ) | | * | ~ | ! | @ | # | $ | % | F6 | | F5 | ^ | & | * | ( | ) | |
* |---------+------+------+------+------+------| | | |------+------+------+------+------+--------| * |---------+------+------+------+------+------| | | |------+------+------+------+------+--------|
* | Del | F1 | F2 | F3 | F4 | F5 |------| |------| F6 | _ | + | { | } | | | * | Del | F1 | F2 | F3 | F4 | F5 |------| |------| F6 | _ | + | { | } | | |
* |---------+------+------+------+------+------| L2 | | L2 |------+------+------+------+------+--------| * |---------+------+------+------+------+------| F12 | | F11 |------+------+------+------+------+--------|
* | | F7 | F8 | F9 | F10 | F11 | | | | F12 |ISO ~ |ISO | | Home | End | | * | | F7 | F8 | F9 | F10 | F11 | | | | F12 |ISO ~ |ISO | | Home | End | |
* `---------+------+------+------+------+-------------' `-------------+------+------+------+------+--------' * `---------+------+------+------+------+-------------' `-------------+------+------+------+------+--------'
* | | | | | | | | Play | Vol- | Vol+ | Next | * | | | | | | | | Play | Vol- | Vol+ | Next |
* `-----------------------------------' `----------------------------------' * `-----------------------------------' `----------------------------------'
* ,-------------. ,-------------. * ,-------------. ,-------------.
* |Animat| | |Toggle|Solid | * | | | | | |
* ,------|------|------| |------+------+------. * ,------|------|------| |------+------+------.
* |Bright|Bright| | | |Hue- |Hue+ | * | | | | | | | |
* |ness- |ness+ |------| |------| | | * | | |------| |------| | |
* | | | | | | | | * | | | | | | | |
* `--------------------' `--------------------' * `--------------------' `--------------------'
*/ */
@ -261,10 +247,10 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
* ,---------------------------------------------------. ,--------------------------------------------------. * ,---------------------------------------------------. ,--------------------------------------------------.
* | Version | F1 | F2 | F3 | F4 | F5 | F11 | | F12 | F6 | F7 | F8 | F9 | F10 | F11 | * | Version | F1 | F2 | F3 | F4 | F5 | F11 | | F12 | F6 | F7 | F8 | F9 | F10 | F11 |
* |---------+------+------+------+------+------+------| |------+------+------+------+------+------+--------| * |---------+------+------+------+------+------+------| |------+------+------+------+------+------+--------|
* | ` | 1 | 2 | 3 | 4 | 5 | | | | 6 | 7 | 8 | 9 | 0 | | * | ` | 1 | 2 | 3 | 4 | 5 | F6 | | F5 | 6 | 7 | 8 | 9 | 0 | |
* |---------+------+------+------+------+------| | | |------+------+------+------+------+--------| * |---------+------+------+------+------+------| | | |------+------+------+------+------+--------|
* | Del | F1 | F2 | F3 | F4 | F5 |------| |------| F6 | - | = | [ | ] | \ | * | Del | F1 | F2 | F3 | F4 | F5 |------| |------| F6 | - | = | [ | ] | \ |
* |---------+------+------+------+------+------| L2 | | L2 |------+------+------+------+------+--------| * |---------+------+------+------+------+------| F12 | | F11 |------+------+------+------+------+--------|
* | | F7 | F8 | F9 | F10 | F11 | | | | F12 |ISO # |ISO / |Pg Up |Pg Dn | | * | | F7 | F8 | F9 | F10 | F11 | | | | F12 |ISO # |ISO / |Pg Up |Pg Dn | |
* `---------+------+------+------+------+-------------' `-------------+------+------+------+------+--------' * `---------+------+------+------+------+-------------' `-------------+------+------+------+------+--------'
* | | | | | | | | Play | Vol- | Vol+ | Next | * | | | | | | | | Play | Vol- | Vol+ | Next |
@ -308,7 +294,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
* |--------+------+------+------+------+-------------| |------+------+------+------+------+------+--------| * |--------+------+------+------+------+-------------| |------+------+------+------+------+------+--------|
* | |Reset |Debug | | | | | | | |TRM on|TRMoff| | | Del | * | |Reset |Debug | | | | | | | |TRM on|TRMoff| | | Del |
* |--------+------+------+------+------+------| | | |------+------+------+------+------+--------| * |--------+------+------+------+------+------| | | |------+------+------+------+------+--------|
* | CPSLCK | | | | |AG Nrm|------| |------|AG Swp|QWERTY|Wrkman|Dvorak| | | * | CPSLCK | | | | |AG Nrm|------| |------|AG Swp|QWERTY|Wrkman|Dvorak|Colmak| |
* |--------+------+------+------+------+------| | | |------+------+------+------+------+--------| * |--------+------+------+------+------+------| | | |------+------+------+------+------+--------|
* | | | | | | | | | | | | Prev | Next | | | * | | | | | | | | | | | | Prev | Next | | |
* `--------+------+------+------+------+-------------' `-------------+------+------+------+------+--------' * `--------+------+------+------+------+-------------' `-------------+------+------+------+------+--------'
@ -325,7 +311,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
[_ADJUST] = LAYOUT_ergodox( [_ADJUST] = LAYOUT_ergodox(
// left hand // left hand
VRSN, _______, _______, _______, _______, _______, _______, VRSN, _______, _______, _______, _______, _______, _______,
_______, RESET, DEBUG, _______, _______, _______, _______, _______, RESET, DEBUG, BL_TOGG, BL_STEP, _______, _______,
KC_CAPS, _______, _______, _______, _______, AG_NORM, KC_CAPS, _______, _______, _______, _______, AG_NORM,
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
@ -502,6 +488,11 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
return MACRO_NONE; return MACRO_NONE;
}; };
void matrix_init_user() {
backlight_enable();
backlight_level(BACKLIGHT_LEVELS);
}
bool process_record_user(uint16_t keycode, keyrecord_t *record) { bool process_record_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case QWERTY: case QWERTY:
@ -576,34 +567,3 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} }
return true; return true;
} }
/**
* 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);
ergodox_board_led_off();
ergodox_led_lower_off();
ergodox_led_raise_off();
ergodox_led_adjust_off();
switch (layer) {
case _LOWER:
ergodox_led_lower_on();
break;
case _RAISE:
ergodox_led_raise_on();
break;
case _ADJUST:
ergodox_led_adjust_on();
break;
}
};

View file

@ -0,0 +1,14 @@
#include QMK_KEYBOARD_H
enum custom_layers {
_QWERTY,
_WORKMAN,
_DVORAK,
_COLEMAK,
_LOWER,
_RAISE,
_ADJUST,
_GAME,
_MOUSE,
_NUM,
};

View file

@ -0,0 +1,123 @@
/* Copyright 2017 Fred Sundvik
*
* 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 KEYBOARDS_ERGODOX_INFINITY_SIMPLE_VISUALIZER_H_
#define KEYBOARDS_ERGODOX_INFINITY_SIMPLE_VISUALIZER_H_
// Currently we are assuming that both the backlight and LCD are enabled
// But it's entirely possible to write a custom visualizer that use only
// one of them
#ifndef LCD_BACKLIGHT_ENABLE
#error This visualizer needs that LCD backlight is enabled
#endif
#ifndef LCD_ENABLE
#error This visualizer needs that LCD is enabled
#endif
#include "visualizer.h"
#include "visualizer_keyframes.h"
#include "lcd_keyframes.h"
#include "lcd_backlight_keyframes.h"
#include "system/serial_link.h"
#include "led.h"
#include "default_animations.h"
static const uint32_t logo_background_color = LCD_COLOR(0x00, 0x00, 0xFF);
static const uint32_t initial_color = LCD_COLOR(0, 0, 0);
static bool initial_update = true;
// Feel free to modify the animations below, or even add new ones if needed
static keyframe_animation_t lcd_layer_display = {
.num_frames = 1,
.loop = false,
.frame_lengths = {gfxMillisecondsToTicks(0)},
.frame_functions = {lcd_keyframe_display_layer_and_led_states}
};
// The color animation animates the LCD color when you change layers
static keyframe_animation_t color_animation = {
.num_frames = 2,
.loop = false,
// Note that there's a 200 ms no-operation frame,
// this prevents the color from changing when activating the layer
// momentarily
.frame_lengths = {gfxMillisecondsToTicks(1), gfxMillisecondsToTicks(5)},
.frame_functions = {keyframe_no_operation, lcd_backlight_keyframe_animate_color},
};
void initialize_user_visualizer(visualizer_state_t* state) {
// The brightness will be dynamically adjustable in the future
// But for now, change it here.
lcd_backlight_brightness(130);
state->current_lcd_color = initial_color;
state->target_lcd_color = logo_background_color;
initial_update = true;
start_keyframe_animation(&default_startup_animation);
}
// This function should be implemented by the keymap visualizer
// Don't change anything else than state->target_lcd_color and state->layer_text as that's the only thing
// that the simple_visualizer assumes that you are updating
// Also make sure that the buffer passed to state->layer_text remains valid until the previous animation is
// stopped. This can be done by either double buffering it or by using constant strings
static void get_visualizer_layer_and_color(visualizer_state_t* state);
void update_user_visualizer_state(visualizer_state_t* state, visualizer_keyboard_status_t* prev_status) {
// Add more tests, change the colors and layer texts here
// Usually you want to check the high bits (higher layers first)
// because that's the order layers are processed for keypresses
// You can for check for example:
// state->status.layer
// state->status.default_layer
// state->status.leds (see led.h for available statuses)
uint32_t prev_color = state->target_lcd_color;
const char* prev_layer_text = state->layer_text;
get_visualizer_layer_and_color(state);
if (initial_update || prev_color != state->target_lcd_color) {
start_keyframe_animation(&color_animation);
}
if (initial_update || prev_layer_text != state->layer_text) {
start_keyframe_animation(&lcd_layer_display);
}
// You can also stop existing animations, and start your custom ones here
// remember that you should normally have only one animation for the LCD
// and one for the background. But you can also combine them if you want.
}
void user_visualizer_suspend(visualizer_state_t* state) {
state->layer_text = "Suspending...";
uint8_t hue = LCD_HUE(state->current_lcd_color);
uint8_t sat = LCD_SAT(state->current_lcd_color);
state->target_lcd_color = LCD_COLOR(hue, sat, 0);
start_keyframe_animation(&default_suspend_animation);
}
void user_visualizer_resume(visualizer_state_t* state) {
state->current_lcd_color = initial_color;
state->target_lcd_color = logo_background_color;
initial_update = true;
start_keyframe_animation(&default_startup_animation);
}
#endif /* KEYBOARDS_ERGODOX_INFINITY_SIMPLE_VISUALIZER_H_ */

View file

@ -1,5 +1,5 @@
/* /*
Copyright 2016 Fred Sundvik <fsundvik@gmail.com> Copyright 2017 Fred Sundvik
This program is free software: you can redistribute it and/or modify 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 it under the terms of the GNU General Public License as published by
@ -15,331 +15,65 @@ You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
/** #include "./simple_visualizer.h"
* Currently we are assuming that both the backlight and LCD are enabled #include "util.h"
* But it's entirely possible to write a custom visualizer that use only #include "layers.h"
* one of them
*/
#ifndef LCD_BACKLIGHT_ENABLE
#error This visualizer needs that LCD backlight is enabled
#endif
#ifndef LCD_ENABLE // This function should be implemented by the keymap visualizer
#error This visualizer needs that LCD is enabled // Don't change anything else than state->target_lcd_color and state->layer_text as that's the only thing
#endif // that the simple_visualizer assumes that you are updating
// Also make sure that the buffer passed to state->layer_text remains valid until the previous animation is
#include "./visualizer.h" // stopped. This can be done by either double buffering it or by using constant strings
#include "visualizer_keyframes.h" static void get_visualizer_layer_and_color(visualizer_state_t* state) {
#include "lcd_keyframes.h" switch(biton32(default_layer_state)) {
#include "lcd_backlight_keyframes.h" case _QWERTY:
#include "system/serial_link.h" state->layer_text = "QWERTY";
#include "default_animations.h" state->target_lcd_color = LCD_COLOR(0, 255, 128);
break;
static const uint32_t logo_background_color = LCD_COLOR(0, 0, 255); case _WORKMAN:
static const uint32_t initial_color = LCD_COLOR(84, 255, 255); state->layer_text = "Workman";
state->target_lcd_color = LCD_COLOR(80, 255, 128);
static const uint32_t led_emulation_colors[4] = { break;
LCD_COLOR(0, 0, 255), case _DVORAK:
LCD_COLOR(141, 255, 255), state->layer_text = "Dvorak";
LCD_COLOR(18, 255, 255), state->target_lcd_color = LCD_COLOR(194, 255, 128);
LCD_COLOR(194, 255, 255), break;
}; case _COLEMAK:
state->layer_text = "Colemak";
static uint32_t next_led_target_color = 0; state->target_lcd_color = LCD_COLOR(18, 255, 128);
break;
typedef enum {
LCD_STATE_INITIAL,
LCD_STATE_LAYER_BITMAP,
LCD_STATE_BITMAP_AND_LEDS,
} lcd_state_t;
static lcd_state_t lcd_state = LCD_STATE_INITIAL;
typedef struct {
uint8_t led_on;
uint8_t led1;
uint8_t led2;
uint8_t led3;
} visualizer_user_data_t;
/**
* Don't access from visualization function, use the visualizer state instead
*/
static visualizer_user_data_t user_data_keyboard = {
.led_on = 0,
.led1 = LED_BRIGHTNESS_HI,
.led2 = LED_BRIGHTNESS_HI,
.led3 = LED_BRIGHTNESS_HI,
};
_Static_assert(sizeof(visualizer_user_data_t) <= VISUALIZER_USER_DATA_SIZE,
"Please increase the VISUALIZER_USER_DATA_SIZE");
// Feel free to modify the animations below, or even add new ones if needed
// The color animation animates the LCD color when you change layers
static keyframe_animation_t one_led_color = {
.num_frames = 1,
.loop = false,
.frame_lengths = {gfxMillisecondsToTicks(0)},
.frame_functions = {lcd_backlight_keyframe_set_color},
};
bool swap_led_target_color(keyframe_animation_t* animation, visualizer_state_t* state) {
uint32_t temp = next_led_target_color;
next_led_target_color = state->target_lcd_color;
state->target_lcd_color = temp;
return false;
} }
// The color animation animates the LCD color when you change layers switch(biton32(state->status.layer)) {
static keyframe_animation_t two_led_colors = { case _LOWER:
.num_frames = 2, state->layer_text = "Lower";
.loop = true, state->target_lcd_color = LCD_COLOR(141, 255, 255);
.frame_lengths = {gfxMillisecondsToTicks(1000), gfxMillisecondsToTicks(0)}, break;
.frame_functions = {lcd_backlight_keyframe_set_color, swap_led_target_color}, case _RAISE:
}; state->layer_text = "Raise";
state->target_lcd_color = LCD_COLOR(18, 255, 255);
/** break;
* The LCD animation alternates between the layer name display and a case _ADJUST:
* bitmap that displays all active layers state->layer_text = "Adjust";
*/ state->target_lcd_color = LCD_COLOR(194, 255, 255);
static keyframe_animation_t lcd_bitmap_animation = { break;
.num_frames = 1, case _NUM:
.loop = false, state->layer_text = "Numpad";
.frame_lengths = {gfxMillisecondsToTicks(0)}, state->target_lcd_color = LCD_COLOR(80, 255, 255);
.frame_functions = {lcd_keyframe_display_layer_bitmap}, break;
}; case _MOUSE:
state->layer_text = "Mouse";
static keyframe_animation_t lcd_bitmap_leds_animation = { state->target_lcd_color = LCD_COLOR(300, 255, 255);
.num_frames = 2, break;
.loop = true, case _GAME:
.frame_lengths = {gfxMillisecondsToTicks(2000), gfxMillisecondsToTicks(2000)}, state->layer_text = "Game";
.frame_functions = {lcd_keyframe_display_layer_bitmap, lcd_keyframe_display_led_states}, state->target_lcd_color = LCD_COLOR(300, 255, 255);
}; break;
case _QWERTY: case _WORKMAN: case _DVORAK: case _COLEMAK:
void initialize_user_visualizer(visualizer_state_t* state) { break;
/** default:
* The brightness will be dynamically adjustable in the future state->layer_text = "NONE";
* But for now, change it here. state->target_lcd_color = LCD_COLOR(0, 255, 255);
*/ break;
lcd_backlight_brightness(180);
state->current_lcd_color = initial_color;
state->target_lcd_color = logo_background_color;
lcd_state = LCD_STATE_INITIAL;
start_keyframe_animation(&default_startup_animation);
}
static inline bool is_led_on(visualizer_user_data_t* user_data, uint8_t num) {
return user_data->led_on & (1u << num);
}
static uint8_t get_led_index_master(visualizer_user_data_t* user_data) {
for (int i=0; i < 4; i++) {
if (is_led_on(user_data, i)) {
return i + 1;
} }
} }
return 0;
}
static uint8_t get_led_index_slave(visualizer_user_data_t* user_data) {
uint8_t master_index = get_led_index_master(user_data);
if (master_index!=0) {
for (int i=master_index; i < 4; i++) {
if (is_led_on(user_data, i)) {
return i + 1;
}
}
}
return 0;
}
static uint8_t get_secondary_led_index(visualizer_user_data_t* user_data) {
if (
is_led_on(user_data, 0) &&
is_led_on(user_data, 1) &&
is_led_on(user_data, 2)
) {
return 3;
}
return 0;
}
static uint8_t get_brightness(visualizer_user_data_t* user_data, uint8_t index) {
switch (index) {
case 1:
return user_data->led1;
case 2:
return user_data->led2;
case 3:
return user_data->led3;
}
return 0;
}
static void update_emulated_leds(visualizer_state_t* state, visualizer_keyboard_status_t* prev_status) {
visualizer_user_data_t* user_data_new = (visualizer_user_data_t*)state->status.user_data;
visualizer_user_data_t* user_data_old = (visualizer_user_data_t*)prev_status->user_data;
uint8_t new_index;
uint8_t old_index;
if (true || is_serial_link_master()) {
new_index = get_led_index_master(user_data_new);
old_index = get_led_index_master(user_data_old);
} else {
new_index = get_led_index_slave(user_data_new);
old_index = get_led_index_slave(user_data_old);
}
uint8_t new_secondary_index = get_secondary_led_index(user_data_new);
uint8_t old_secondary_index = get_secondary_led_index(user_data_old);
uint8_t new_brightness = get_brightness(user_data_new, new_index);
uint8_t old_brightness = get_brightness(user_data_old, old_index);
uint8_t new_secondary_brightness = get_brightness(user_data_new, new_secondary_index);
uint8_t old_secondary_brightness = get_brightness(user_data_old, old_secondary_index);
if (
lcd_state == LCD_STATE_INITIAL ||
new_index != old_index ||
new_secondary_index != old_secondary_index ||
new_brightness != old_brightness ||
new_secondary_brightness != old_secondary_brightness
) {
if (new_secondary_index != 0) {
state->target_lcd_color = change_lcd_color_intensity(
led_emulation_colors[new_index], new_brightness);
next_led_target_color = change_lcd_color_intensity(
led_emulation_colors[new_secondary_index], new_secondary_brightness);
stop_keyframe_animation(&one_led_color);
start_keyframe_animation(&two_led_colors);
} else {
state->target_lcd_color = change_lcd_color_intensity(
led_emulation_colors[new_index], new_brightness);
stop_keyframe_animation(&two_led_colors);
start_keyframe_animation(&one_led_color);
}
}
}
static void update_lcd_text(visualizer_state_t* state, visualizer_keyboard_status_t* prev_status) {
if (state->status.leds) {
if (
lcd_state != LCD_STATE_BITMAP_AND_LEDS ||
state->status.leds != prev_status->leds ||
state->status.layer != prev_status->layer ||
state->status.default_layer != prev_status->default_layer
) {
// NOTE: that it doesn't matter if the animation isn't playing, stop will do nothing in that case
stop_keyframe_animation(&lcd_bitmap_animation);
lcd_state = LCD_STATE_BITMAP_AND_LEDS;
/**
* For information:
* The logic in this function makes sure that this doesn't happen, but if you call start on an
* animation that is already playing it will be restarted.
*/
start_keyframe_animation(&lcd_bitmap_leds_animation);
}
} else {
if (
lcd_state != LCD_STATE_LAYER_BITMAP ||
state->status.layer != prev_status->layer ||
state->status.default_layer != prev_status->default_layer
) {
stop_keyframe_animation(&lcd_bitmap_leds_animation);
lcd_state = LCD_STATE_LAYER_BITMAP;
start_keyframe_animation(&lcd_bitmap_animation);
}
}
}
void update_user_visualizer_state(visualizer_state_t* state, visualizer_keyboard_status_t* prev_status) {
/**
* Check the status here to start and stop animations
* You might have to save some state, like the current animation here so that you can start the right
* This function is called every time the status changes
*
* NOTE that this is called from the visualizer thread, so don't access anything else outside the status
* This is also important because the slave won't have access to the active layer for example outside the
* status.
*/
update_emulated_leds(state, prev_status);
update_lcd_text(state, prev_status);
}
void user_visualizer_suspend(visualizer_state_t* state) {
state->layer_text = "Suspending...";
uint8_t hue = LCD_HUE(state->current_lcd_color);
uint8_t sat = LCD_SAT(state->current_lcd_color);
state->target_lcd_color = LCD_COLOR(hue, sat, 0);
start_keyframe_animation(&default_suspend_animation);
}
void user_visualizer_resume(visualizer_state_t* state) {
state->current_lcd_color = initial_color;
state->target_lcd_color = logo_background_color;
lcd_state = LCD_STATE_INITIAL;
start_keyframe_animation(&default_startup_animation);
}
void ergodox_board_led_on(void){
// No board led support
}
void ergodox_led_lower_on(void){
user_data_keyboard.led_on |= (1u << 0);
visualizer_set_user_data(&user_data_keyboard);
}
void ergodox_led_raise_on(void){
user_data_keyboard.led_on |= (1u << 1);
visualizer_set_user_data(&user_data_keyboard);
}
void ergodox_led_adjust_on(void){
user_data_keyboard.led_on |= (1u << 2);
visualizer_set_user_data(&user_data_keyboard);
}
void ergodox_board_led_off(void){
// No board led support
}
void ergodox_led_lower_off(void){
user_data_keyboard.led_on &= ~(1u << 0);
visualizer_set_user_data(&user_data_keyboard);
}
void ergodox_led_raise_off(void){
user_data_keyboard.led_on &= ~(1u << 1);
visualizer_set_user_data(&user_data_keyboard);
}
void ergodox_led_adjust_off(void){
user_data_keyboard.led_on &= ~(1u << 2);
visualizer_set_user_data(&user_data_keyboard);
}
void ergodox_led_lower_set(uint8_t n) {
user_data_keyboard.led1 = n;
visualizer_set_user_data(&user_data_keyboard);
}
void ergodox_led_raise_set(uint8_t n) {
user_data_keyboard.led2 = n;
visualizer_set_user_data(&user_data_keyboard);
}
void ergodox_led_adjust_set(uint8_t n) {
user_data_keyboard.led3 = n;
visualizer_set_user_data(&user_data_keyboard);
}