From c5ffd182c8daeaa0b50c45f4f959b5615ae2a6e6 Mon Sep 17 00:00:00 2001 From: Louis Orleans Date: Fri, 4 Oct 2019 20:32:52 -0700 Subject: [PATCH] [Keymap] update my keymap for Infinity Ergodox (#6864) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * 🎉 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 --- .../keymaps/dudeofawesome/keymap.c | 174 +++----- .../keymaps/dudeofawesome/layers.h | 14 + .../keymaps/dudeofawesome/simple_visualizer.h | 123 ++++++ .../keymaps/dudeofawesome/visualizer.c | 382 +++--------------- 4 files changed, 262 insertions(+), 431 deletions(-) create mode 100644 keyboards/ergodox_infinity/keymaps/dudeofawesome/layers.h create mode 100644 keyboards/ergodox_infinity/keymaps/dudeofawesome/simple_visualizer.h diff --git a/keyboards/ergodox_infinity/keymaps/dudeofawesome/keymap.c b/keyboards/ergodox_infinity/keymaps/dudeofawesome/keymap.c index cf0b452bd..26de392f9 100644 --- a/keyboards/ergodox_infinity/keymaps/dudeofawesome/keymap.c +++ b/keyboards/ergodox_infinity/keymaps/dudeofawesome/keymap.c @@ -1,20 +1,6 @@ #include QMK_KEYBOARD_H -#include "debug.h" -#include "action_layer.h" #include "version.h" - -enum custom_layers { - _QWERTY, - _WORKMAN, - _DVORAK, - _COLEMAK, - _LOWER, - _RAISE, - _ADJUST, - _GAME, - _MOUSE, - _NUM, -}; +#include "layers.h" enum custom_keycodes { QWERTY = SAFE_RANGE, @@ -39,41 +25,41 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { * | Tab | Q | W | E | R | T | [{ | | ]} | Y | U | I | O | P | BSPC | * |--------+-----+-----+-----+-----+-----| | | |-----+-----+-----+-----+-----+--------| * | ESC | A | S | D | F | G |------| |------| H | J | K | L | ; | ' | - * |--------+-----+-----+-----+-----+-----| L1 | | L1 |-----+-----+-----+-----+-----+--------| + * |--------+-----+-----+-----+-----+-----| | | |-----+-----+-----+-----+-----+--------| * | LShift | Z | X | C | V | B | | | | N | M | , | . | / | Enter | * `--------+-----+-----+-----+-----+------------' `------------+-----+-----+-----+-----+--------' * | Num |Ctrl | Alt |LGUI |Lower| |Raise|Left |Down | Up |Right | * `------------------------------' `------------------------------' * ,------------. ,------------. - * |Play |Mouse | | Num |Mouse| - * ,----|-----|------| |------+-----+-----. - * | | | Alt | | Alt | | | - * |BSPC|LOWER|------| |------|RAISE|Space| - * | | | LGUI | | LGUI | | | - * `-----------------' `------------------' + * |Play | | | |Play | + * ,-----|-----|------| |------+-----+-----. + * | | | Alt | | Alt | | | + * |Space|LOWER|------| |------|RAISE|Space| + * | | | LGUI | | LGUI | | | + * `------------------' `------------------' */ [_QWERTY] = LAYOUT_ergodox( // left hand 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_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, - KC_MPLY, TG(_MOUSE), + KC_MPLY, _______, KC_LALT, - KC_BSPACE, LOWER, KC_LGUI, + KC_SPACE, LOWER, KC_LGUI, // right hand 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_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, - TT(_NUM), TG(_MOUSE), + _______, KC_MPLY, KC_LALT, - KC_LGUI, RAISE, KC_SPACE + KC_LGUI, RAISE, KC_SPACE ), /* Keymap 0: Basic Workman layer @@ -84,41 +70,41 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { * | Tab | Q | D | R | W | B | [{ | | ]} | J | F | U | P | ; | BSPC | * |--------+-----+-----+-----+-----+-----| | | |-----+-----+-----+-----+-----+--------| * | ESC | A | S | H | T | G |------| |------| Y | N | E | O | I | ' | - * |--------+-----+-----+-----+-----+-----| L1 | | L1 |-----+-----+-----+-----+-----+--------| + * |--------+-----+-----+-----+-----+-----| | | |-----+-----+-----+-----+-----+--------| * | LShift | Z | X | M | C | V | | | | K | L | , | . | / | Enter | * `--------+-----+-----+-----+-----+------------' `------------+-----+-----+-----+-----+--------' * | Num |Ctrl | Alt |LGUI |Lower| |Raise|Left |Down | Up |Right | * `------------------------------' `------------------------------' * ,------------. ,------------. - * |Play |Mouse | | Num |Mouse| - * ,----|-----|------| |------+-----+-----. - * | | | Alt | | Alt | | | - * |BSPC|LOWER|------| |------|RAISE|Space| - * | | | LGUI | | LGUI | | | - * `-----------------' `------------------' + * |Play | | | |Play | + * ,-----|-----|------| |------+-----+-----. + * | | | Alt | | Alt | | | + * |Space|LOWER|------| |------|RAISE|Space| + * | | | LGUI | | LGUI | | | + * `------------------' `------------------' */ [_WORKMAN] = LAYOUT_ergodox( // left hand 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_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, - KC_MPLY, TG(_MOUSE), + KC_MPLY, _______, KC_LALT, - KC_BSPACE, LOWER, KC_LGUI, + KC_SPACE, LOWER, KC_LGUI, // right hand 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_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, - TT(_NUM), TG(_MOUSE), + _______, KC_MPLY, KC_LALT, - KC_LGUI, RAISE, KC_SPACE + KC_LGUI, RAISE, KC_SPACE ), /* Keymap 0: Basic Dvorak layer @@ -129,41 +115,41 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { * | Tab | ' | , | . | P | Y | [{ | | ]} | F | G | C | R | L | BSPC | * |--------+-----+-----+-----+-----+-----| | | |-----+-----+-----+-----+-----+--------| * | ESC | A | O | E | U | I |------| |------| D | H | T | N | S | / | - * |--------+-----+-----+-----+-----+-----| L1 | | L1 |-----+-----+-----+-----+-----+--------| + * |--------+-----+-----+-----+-----+-----| | | |-----+-----+-----+-----+-----+--------| * | LShift | ; | Q | J | K | X | | | | B | M | W | V | Z | Enter | * `--------+-----+-----+-----+-----+------------' `------------+-----+-----+-----+-----+--------' * | Num |Ctrl | Alt |LGUI |Lower| |Raise|Left |Down | Up |Right | * `------------------------------' `------------------------------' * ,------------. ,------------. - * |Play |Mouse | | Num |Mouse| - * ,----|-----|------| |------+-----+-----. - * | | | Alt | | Alt | | | - * |BSPC|LOWER|------| |------|RAISE|Space| - * | | | LGUI | | LGUI | | | - * `-----------------' `------------------' + * |Play | | | |Play | + * ,-----|-----|------| |------+-----+-----. + * | | | Alt | | Alt | | | + * |Space|LOWER|------| |------|RAISE|Space| + * | | | LGUI | | LGUI | | | + * `------------------' `------------------' */ [_DVORAK] = LAYOUT_ergodox( // left hand 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_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, - KC_MPLY, TG(_MOUSE), + KC_MPLY, _______, KC_LALT, - KC_BSPACE, LOWER, KC_LGUI, + KC_SPACE, LOWER, KC_LGUI, // right hand 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_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, - TT(_NUM), TG(_MOUSE), + _______, KC_MPLY, KC_LALT, - KC_LGUI, RAISE, KC_SPACE + KC_LGUI, RAISE, KC_SPACE ), /* Keymap 0: Basic Colemak layer @@ -174,41 +160,41 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { * | Tab | Q | W | F | P | G | [{ | | ]} | J | L | U | Y | ; | BSPC | * |--------+-----+-----+-----+-----+-----| | | |-----+-----+-----+-----+-----+--------| * | ESC | A | R | S | T | D |------| |------| H | N | E | I | O | ' | - * |--------+-----+-----+-----+-----+-----| L1 | | L1 |-----+-----+-----+-----+-----+--------| + * |--------+-----+-----+-----+-----+-----| | | |-----+-----+-----+-----+-----+--------| * | LShift | Z | X | C | V | B | | | | K | M | , | . | / | Enter | * `--------+-----+-----+-----+-----+------------' `------------+-----+-----+-----+-----+--------' * | Num |Ctrl | Alt |LGUI |Lower| |Raise|Left |Down | Up |Right | * `------------------------------' `------------------------------' * ,------------. ,------------. - * |Play |Mouse | | Num |Mouse| - * ,----|-----|------| |------+-----+-----. - * | | | Alt | | Alt | | | - * |BSPC|LOWER|------| |------|RAISE|Space| - * | | | LGUI | | LGUI | | | - * `-----------------' `------------------' + * |Play | | | |Play | + * ,-----|-----|------| |------+-----+-----. + * | | | Alt | | Alt | | | + * |Space|LOWER|------| |------|RAISE|Space| + * | | | LGUI | | LGUI | | | + * `------------------' `------------------' */ [_COLEMAK] = LAYOUT_ergodox( // left hand 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_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, - KC_MPLY, TG(_MOUSE), + KC_MPLY, _______, KC_LALT, - KC_BSPACE, LOWER, KC_LGUI, + KC_SPACE, LOWER, KC_LGUI, // right hand 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_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, - TT(_NUM), TG(_MOUSE), + _______, KC_MPLY, KC_LALT, - KC_LGUI, RAISE, KC_SPACE + KC_LGUI, RAISE, KC_SPACE ), /* Lower @@ -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 | | * |---------+------+------+------+------+------+------| |------+------+------+------+------+------+--------| - * | ~ | ! | @ | # | $ | % | | | | ^ | & | * | ( | ) | | + * | ~ | ! | @ | # | $ | % | F6 | | F5 | ^ | & | * | ( | ) | | * |---------+------+------+------+------+------| | | |------+------+------+------+------+--------| * | Del | F1 | F2 | F3 | F4 | F5 |------| |------| F6 | _ | + | { | } | | | - * |---------+------+------+------+------+------| L2 | | L2 |------+------+------+------+------+--------| + * |---------+------+------+------+------+------| F12 | | F11 |------+------+------+------+------+--------| * | | F7 | F8 | F9 | F10 | F11 | | | | F12 |ISO ~ |ISO | | Home | End | | * `---------+------+------+------+------+-------------' `-------------+------+------+------+------+--------' * | | | | | | | | 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 | * |---------+------+------+------+------+------+------| |------+------+------+------+------+------+--------| - * | ` | 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 | - | = | [ | ] | \ | - * |---------+------+------+------+------+------| L2 | | L2 |------+------+------+------+------+--------| + * |---------+------+------+------+------+------| F12 | | F11 |------+------+------+------+------+--------| * | | F7 | F8 | F9 | F10 | F11 | | | | F12 |ISO # |ISO / |Pg Up |Pg Dn | | * `---------+------+------+------+------+-------------' `-------------+------+------+------+------+--------' * | | | | | | | | Play | Vol- | Vol+ | Next | @@ -308,7 +294,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { * |--------+------+------+------+------+-------------| |------+------+------+------+------+------+--------| * | |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 | | | * `--------+------+------+------+------+-------------' `-------------+------+------+------+------+--------' @@ -325,7 +311,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { [_ADJUST] = LAYOUT_ergodox( // left hand VRSN, _______, _______, _______, _______, _______, _______, - _______, RESET, DEBUG, _______, _______, _______, _______, + _______, RESET, DEBUG, BL_TOGG, BL_STEP, _______, _______, 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; }; +void matrix_init_user() { + backlight_enable(); + backlight_level(BACKLIGHT_LEVELS); +} + bool process_record_user(uint16_t keycode, keyrecord_t *record) { switch (keycode) { case QWERTY: @@ -576,34 +567,3 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { } 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; - } -}; diff --git a/keyboards/ergodox_infinity/keymaps/dudeofawesome/layers.h b/keyboards/ergodox_infinity/keymaps/dudeofawesome/layers.h new file mode 100644 index 000000000..d852fe980 --- /dev/null +++ b/keyboards/ergodox_infinity/keymaps/dudeofawesome/layers.h @@ -0,0 +1,14 @@ +#include QMK_KEYBOARD_H + +enum custom_layers { + _QWERTY, + _WORKMAN, + _DVORAK, + _COLEMAK, + _LOWER, + _RAISE, + _ADJUST, + _GAME, + _MOUSE, + _NUM, +}; diff --git a/keyboards/ergodox_infinity/keymaps/dudeofawesome/simple_visualizer.h b/keyboards/ergodox_infinity/keymaps/dudeofawesome/simple_visualizer.h new file mode 100644 index 000000000..9213e99f4 --- /dev/null +++ b/keyboards/ergodox_infinity/keymaps/dudeofawesome/simple_visualizer.h @@ -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 . + */ + +#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_ */ diff --git a/keyboards/ergodox_infinity/keymaps/dudeofawesome/visualizer.c b/keyboards/ergodox_infinity/keymaps/dudeofawesome/visualizer.c index d339ecc97..54fc2363c 100644 --- a/keyboards/ergodox_infinity/keymaps/dudeofawesome/visualizer.c +++ b/keyboards/ergodox_infinity/keymaps/dudeofawesome/visualizer.c @@ -1,5 +1,5 @@ /* -Copyright 2016 Fred Sundvik +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 @@ -15,331 +15,65 @@ You should have received a copy of the GNU General Public License along with this program. If not, see . */ -/** - * 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 +#include "./simple_visualizer.h" +#include "util.h" +#include "layers.h" -#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 "default_animations.h" - -static const uint32_t logo_background_color = LCD_COLOR(0, 0, 255); -static const uint32_t initial_color = LCD_COLOR(84, 255, 255); - -static const uint32_t led_emulation_colors[4] = { - LCD_COLOR(0, 0, 255), - LCD_COLOR(141, 255, 255), - LCD_COLOR(18, 255, 255), - LCD_COLOR(194, 255, 255), -}; - -static uint32_t next_led_target_color = 0; - -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 -static keyframe_animation_t two_led_colors = { - .num_frames = 2, - .loop = true, - .frame_lengths = {gfxMillisecondsToTicks(1000), gfxMillisecondsToTicks(0)}, - .frame_functions = {lcd_backlight_keyframe_set_color, swap_led_target_color}, -}; - -/** - * The LCD animation alternates between the layer name display and a - * bitmap that displays all active layers - */ -static keyframe_animation_t lcd_bitmap_animation = { - .num_frames = 1, - .loop = false, - .frame_lengths = {gfxMillisecondsToTicks(0)}, - .frame_functions = {lcd_keyframe_display_layer_bitmap}, -}; - -static keyframe_animation_t lcd_bitmap_leds_animation = { - .num_frames = 2, - .loop = true, - .frame_lengths = {gfxMillisecondsToTicks(2000), gfxMillisecondsToTicks(2000)}, - .frame_functions = {lcd_keyframe_display_layer_bitmap, lcd_keyframe_display_led_states}, -}; - -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(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; - } - } +// 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) { + switch(biton32(default_layer_state)) { + case _QWERTY: + state->layer_text = "QWERTY"; + state->target_lcd_color = LCD_COLOR(0, 255, 128); + break; + case _WORKMAN: + state->layer_text = "Workman"; + state->target_lcd_color = LCD_COLOR(80, 255, 128); + break; + case _DVORAK: + state->layer_text = "Dvorak"; + state->target_lcd_color = LCD_COLOR(194, 255, 128); + break; + case _COLEMAK: + state->layer_text = "Colemak"; + state->target_lcd_color = LCD_COLOR(18, 255, 128); + break; } - 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); - } + switch(biton32(state->status.layer)) { + case _LOWER: + state->layer_text = "Lower"; + state->target_lcd_color = LCD_COLOR(141, 255, 255); + break; + case _RAISE: + state->layer_text = "Raise"; + state->target_lcd_color = LCD_COLOR(18, 255, 255); + break; + case _ADJUST: + state->layer_text = "Adjust"; + state->target_lcd_color = LCD_COLOR(194, 255, 255); + break; + case _NUM: + state->layer_text = "Numpad"; + state->target_lcd_color = LCD_COLOR(80, 255, 255); + break; + case _MOUSE: + state->layer_text = "Mouse"; + state->target_lcd_color = LCD_COLOR(300, 255, 255); + break; + case _GAME: + state->layer_text = "Game"; + state->target_lcd_color = LCD_COLOR(300, 255, 255); + break; + case _QWERTY: case _WORKMAN: case _DVORAK: case _COLEMAK: + break; + default: + state->layer_text = "NONE"; + state->target_lcd_color = LCD_COLOR(0, 255, 255); + break; } } - -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); -}