From 89c528e443561731eb3cf4ed3d49002545421afe Mon Sep 17 00:00:00 2001 From: Josh Johnson Date: Tue, 11 Feb 2020 00:16:27 +1100 Subject: [PATCH] [Keyboard] Add support for Hub16 (#7794) Co-Authored-By: James Young <18669334+noroadsleft@users.noreply.github.com> Co-Authored-By: fauxpark --- keyboards/hub16/config.h | 97 ++++++++ keyboards/hub16/hub16.c | 16 ++ keyboards/hub16/hub16.h | 42 ++++ keyboards/hub16/keymaps/default/keymap.c | 96 ++++++++ keyboards/hub16/keymaps/no_mod/keymap.c | 63 ++++++ keyboards/hub16/matrix.c | 270 +++++++++++++++++++++++ keyboards/hub16/readme.md | 15 ++ keyboards/hub16/rules.mk | 38 ++++ 8 files changed, 637 insertions(+) create mode 100755 keyboards/hub16/config.h create mode 100755 keyboards/hub16/hub16.c create mode 100755 keyboards/hub16/hub16.h create mode 100755 keyboards/hub16/keymaps/default/keymap.c create mode 100755 keyboards/hub16/keymaps/no_mod/keymap.c create mode 100644 keyboards/hub16/matrix.c create mode 100755 keyboards/hub16/readme.md create mode 100755 keyboards/hub16/rules.mk diff --git a/keyboards/hub16/config.h b/keyboards/hub16/config.h new file mode 100755 index 000000000..c7dec995e --- /dev/null +++ b/keyboards/hub16/config.h @@ -0,0 +1,97 @@ +/* +Copyright 2019 Josh Johnson + +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 . +*/ + +#pragma once + +#include "config_common.h" + +/* USB Device descriptor parameter */ +#define VENDOR_ID 0xFEED +#define PRODUCT_ID 0x8F73 +#define DEVICE_VER 0x0001 +#define MANUFACTURER Josh Johnson +#define PRODUCT Hub16 +#define DESCRIPTION Macro Pad with USB Hub and Encoders + +/* key matrix size */ +#define MATRIX_ROWS 5 +#define MATRIX_COLS 4 + +/* + * Keyboard Matrix Assignments + * + * Change this to how you wired your keyboard + * COLS: AVR pins used for columns, left to right + * ROWS: AVR pins used for rows, top to bottom + * DIODE_DIRECTION: COL2ROW = COL = Anode (+), ROW = Cathode (-, marked on diode) + * ROW2COL = ROW = Anode (+), COL = Cathode (-, marked on diode) + * + */ +#define MATRIX_ROW_PINS \ + { F0, C7, C6, B6, E6} +#define MATRIX_COL_PINS \ + { F4, F1, D5, D3 } + +/* COL2ROW, ROW2COL*/ +#define DIODE_DIRECTION COL2ROW + +#define RGB_DI_PIN D1 +// #ifdef RGB_DI_PIN +#define RGBLED_NUM 11 +#define RGBLIGHT_HUE_STEP 8 +#define RGBLIGHT_SAT_STEP 8 +#define RGBLIGHT_VAL_STEP 8 +#define RGBLIGHT_LIMIT_VAL 255 /* The maximum brightness level */ +#define RGBLIGHT_SLEEP /* If defined, the RGB lighting will be switched off when the host goes to sleep */ +// /*== all animations enable ==*/ +// #define RGBLIGHT_ANIMATIONS +// /*== or choose animations ==*/ +#define RGBLIGHT_EFFECT_BREATHING +#define RGBLIGHT_EFFECT_RAINBOW_MOOD +#define RGBLIGHT_EFFECT_RAINBOW_SWIRL +#define RGBLIGHT_EFFECT_SNAKE +#define RGBLIGHT_EFFECT_KNIGHT +// #define RGBLIGHT_EFFECT_CHRISTMAS +// #define RGBLIGHT_EFFECT_STATIC_GRADIENT +// #define RGBLIGHT_EFFECT_RGB_TEST +// #define RGBLIGHT_EFFECT_ALTERNATING +// /*== customize breathing effect ==*/ +// /*==== (DEFAULT) use fixed table instead of exp() and sin() ====*/ +// #define RGBLIGHT_BREATHE_TABLE_SIZE 256 // 256(default) or 128 or 64 +// /*==== use exp() and sin() ====*/ +// #define RGBLIGHT_EFFECT_BREATHE_CENTER 1.85 // 1 to 2.7 +// #define RGBLIGHT_EFFECT_BREATHE_MAX 255 // 0 to 255 +// #endif + +/* Debounce reduces chatter (unintended double-presses) - set 0 if debouncing is not needed */ +#define DEBOUNCE 20 + +/* ENCODER THINGS */ + +// #define NUMBER_OF_ENCODERS 2 +#define ENCODERS_PAD_A \ + { F6, B4 } +#define ENCODERS_PAD_B \ + { F5, B5 } + +/* Tap Dance timing */ +#define TAPPING_TERM 200 + +/* 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 diff --git a/keyboards/hub16/hub16.c b/keyboards/hub16/hub16.c new file mode 100755 index 000000000..e18ba5526 --- /dev/null +++ b/keyboards/hub16/hub16.c @@ -0,0 +1,16 @@ +/* Copyright 2019 Josh Johnson + * + * 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 . + */ +#include "hub16.h" \ No newline at end of file diff --git a/keyboards/hub16/hub16.h b/keyboards/hub16/hub16.h new file mode 100755 index 000000000..36830bf5c --- /dev/null +++ b/keyboards/hub16/hub16.h @@ -0,0 +1,42 @@ +/* Copyright 2019 Josh Johnson + * + * 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 . + */ +#pragma once + +#include "quantum.h" +#define ___ KC_NO + +/* This a shortcut to help you visually see your layout. + * + * The first section contains all of the arguments representing the physical + * layout of the board and position of the keys. + * + * The second converts the arguments into a two-dimensional array which + * represents the switch matrix. + */ +#define LAYOUT( \ + k40, k41, \ + 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, }, \ + { k40, k41, ___, ___, } \ +} + diff --git a/keyboards/hub16/keymaps/default/keymap.c b/keyboards/hub16/keymaps/default/keymap.c new file mode 100755 index 000000000..a77c8bc78 --- /dev/null +++ b/keyboards/hub16/keymaps/default/keymap.c @@ -0,0 +1,96 @@ +/* Copyright 2019 Josh Johnson + * + * 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 . + */ +#include QMK_KEYBOARD_H + +// Function key we are 'wrapping' usual key presses in +#define KC_WRAP KC_F24 + +// Tap Dance Declarations +enum { TD_TO_LED = 0, TD_TO_DEFAULT = 1 }; + +qk_tap_dance_action_t tap_dance_actions[] = { + // Tap once for HID, twice to toggle layer 1 + [TD_TO_LED] = ACTION_TAP_DANCE_DUAL_ROLE(_______, 1), + [TD_TO_DEFAULT] = ACTION_TAP_DANCE_DUAL_ROLE(_______, 0)}; + +const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { + [0] = LAYOUT( /* Base */ + KC_S, KC_V, + KC_A, KC_B, KC_C, KC_D, + KC_E, KC_F, KC_G, KC_H, + KC_I, KC_J, KC_K, KC_L, + KC_M, KC_N, KC_O, TD(TD_TO_LED) + ), + + [1] = LAYOUT( /* LED Control */ + KC_NO, KC_NO, + _______, RGB_MOD, RGB_RMOD, RGB_TOG, + RGB_VAD, RGB_VAI, RGB_HUD, RGB_HUI, + RGB_SAD, RGB_SAI, _______, _______, + _______, _______, RESET, TD(TD_TO_DEFAULT) + ), +}; + +// Keyboard is setup to 'warp' the pressed key with F24, +// allowing for easy differentiation from a real keyboard. +void encoder_update_user(uint8_t index, bool clockwise) { + if (index == 0) { /* Left Encoder */ + if (clockwise) { + register_code(KC_WRAP); + tap_code(KC_R); + unregister_code(KC_WRAP); + } else { + register_code(KC_WRAP); + tap_code(KC_Q); + unregister_code(KC_WRAP); + } + } else if (index == 1) { /* Right Encoder */ + if (clockwise) { + register_code(KC_WRAP); + tap_code(KC_U); + unregister_code(KC_WRAP); + } else { + register_code(KC_WRAP); + tap_code(KC_T); + unregister_code(KC_WRAP); + } + } +} + +// Below stolen from TaranVH (https://github.com/TaranVH/2nd-keyboard/blob/master/HASU_USB/F24/keymap.c) +// Shoutout to drashna on the QMK discord for basically writing this for me.... :P + +bool process_record_user(uint16_t keycode, keyrecord_t *record) { + static uint8_t f24_tracker; + switch (keycode) { + case KC_A ... KC_F23: + case KC_EXECUTE ... KC_EXSEL: + if (record->event.pressed) { + register_code(KC_WRAP); + f24_tracker++; + register_code(keycode); + } else { + unregister_code(keycode); + f24_tracker--; + if (!f24_tracker) { + unregister_code(KC_WRAP); + } + } + return false; + break; + } + return true; +} diff --git a/keyboards/hub16/keymaps/no_mod/keymap.c b/keyboards/hub16/keymaps/no_mod/keymap.c new file mode 100755 index 000000000..c86ffcc16 --- /dev/null +++ b/keyboards/hub16/keymaps/no_mod/keymap.c @@ -0,0 +1,63 @@ +/* Copyright 2019 Josh Johnson + * + * 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 . + */ +#include QMK_KEYBOARD_H + +// Function key we are 'wrapping' usual key presses in +#define KC_WRAP KC_F24 + +// Tap Dance Declarations +enum { TD_TO_LED = 0, TD_TO_DEFAULT = 1 }; + +qk_tap_dance_action_t tap_dance_actions[] = { + // Tap once for HID, twice to toggle layer 1 + [TD_TO_LED] = ACTION_TAP_DANCE_DUAL_ROLE(_______, 1), + [TD_TO_DEFAULT] = ACTION_TAP_DANCE_DUAL_ROLE(_______, 0)}; + +const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { + [0] = LAYOUT( /* Base */ + KC_S, KC_V, + KC_A, KC_B, KC_C, KC_D, + KC_E, KC_F, KC_G, KC_H, + KC_I, KC_J, KC_K, KC_L, + KC_M, KC_N, KC_O, TD(TD_TO_LED) + ), + + [1] = LAYOUT( /* LED Control */ + KC_NO, KC_NO, + _______, RGB_MOD, RGB_RMOD, RGB_TOG, + RGB_VAD, RGB_VAI, RGB_HUD, RGB_HUI, + RGB_SAD, RGB_SAI, _______, _______, + _______, _______, RESET, TD(TD_TO_DEFAULT) + ), +}; + +// Keyboard is setup to 'warp' the pressed key with F24, +// allowing for easy differentiation from a real keyboard. +void encoder_update_user(uint8_t index, bool clockwise) { + if (index == 0) { /* Left Encoder */ + if (clockwise) { + tap_code(KC_R); + } else { + tap_code(KC_Q); + } + } else if (index == 1) { /* Right Encoder */ + if (clockwise) { + tap_code(KC_U); + } else { + tap_code(KC_T); + } + } +} \ No newline at end of file diff --git a/keyboards/hub16/matrix.c b/keyboards/hub16/matrix.c new file mode 100644 index 000000000..ad77c923b --- /dev/null +++ b/keyboards/hub16/matrix.c @@ -0,0 +1,270 @@ +/* +Copyright 2012-2018 Jun Wako, Jack Humbert, Yiancar + +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 . +*/ +#include +#include +#include "wait.h" +#include "util.h" +#include "matrix.h" +#include "debounce.h" +#include "quantum.h" + +// Encoder things +#define SWITCH_1 F7 +#define SWITCH_2 D7 +static bool read_encoder_values(matrix_row_t current_matrix[], uint8_t current_row); + +#ifdef MATRIX_MASKED +extern const matrix_row_t matrix_mask[]; +#endif + +#ifdef DIRECT_PINS +static pin_t direct_pins[MATRIX_ROWS][MATRIX_COLS] = DIRECT_PINS; +#elif (DIODE_DIRECTION == ROW2COL) || (DIODE_DIRECTION == COL2ROW) +static const pin_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS; +static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS; +#endif + +/* matrix state(1:on, 0:off) */ +static matrix_row_t raw_matrix[MATRIX_ROWS]; // raw values +static matrix_row_t matrix[MATRIX_ROWS]; // debounced values + +// helper functions + +inline bool matrix_is_on(uint8_t row, uint8_t col) { return (matrix[row] & ((matrix_row_t)1 << col)); } + +inline matrix_row_t matrix_get_row(uint8_t row) { + // Matrix mask lets you disable switches in the returned matrix data. For example, if you have a + // switch blocker installed and the switch is always pressed. +#ifdef MATRIX_MASKED + return matrix[row] & matrix_mask[row]; +#else + return matrix[row]; +#endif +} + +// matrix code + +#ifdef DIRECT_PINS + +static void init_pins(void) { + for (int row = 0; row < MATRIX_ROWS; row++) { + for (int col = 0; col < MATRIX_COLS; col++) { + pin_t pin = direct_pins[row][col]; + if (pin != NO_PIN) { + setPinInputHigh(pin); + } + } + } +} + +static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row) { + matrix_row_t last_row_value = current_matrix[current_row]; + current_matrix[current_row] = 0; + + for (uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) { + pin_t pin = direct_pins[current_row][col_index]; + if (pin != NO_PIN) { + current_matrix[current_row] |= readPin(pin) ? 0 : (MATRIX_ROW_SHIFTER << col_index); + } + } + + return (last_row_value != current_matrix[current_row]); +} + +#elif (DIODE_DIRECTION == COL2ROW) + +static void select_row(uint8_t row) { + setPinOutput(row_pins[row]); + writePinLow(row_pins[row]); +} + +static void unselect_row(uint8_t row) { setPinInputHigh(row_pins[row]); } + +static void unselect_rows(void) { + for (uint8_t x = 0; x < MATRIX_ROWS; x++) { + setPinInputHigh(row_pins[x]); + } +} + +static void init_pins(void) { + unselect_rows(); + for (uint8_t x = 0; x < MATRIX_COLS; x++) { + setPinInputHigh(col_pins[x]); + } +} + +static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row) { + // Store last value of row prior to reading + matrix_row_t last_row_value = current_matrix[current_row]; + + // Clear data in matrix row + current_matrix[current_row] = 0; + + // Select row and wait for row selecton to stabilize + select_row(current_row); + wait_us(30); + + // For each col... + for (uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) { + // Select the col pin to read (active low) + uint8_t pin_state = readPin(col_pins[col_index]); + + // Populate the matrix row with the state of the col pin + current_matrix[current_row] |= pin_state ? 0 : (MATRIX_ROW_SHIFTER << col_index); + } + + // Unselect row + unselect_row(current_row); + + return (last_row_value != current_matrix[current_row]); +} + +#elif (DIODE_DIRECTION == ROW2COL) + +static void select_col(uint8_t col) { + setPinOutput(col_pins[col]); + writePinLow(col_pins[col]); +} + +static void unselect_col(uint8_t col) { setPinInputHigh(col_pins[col]); } + +static void unselect_cols(void) { + for (uint8_t x = 0; x < MATRIX_COLS; x++) { + setPinInputHigh(col_pins[x]); + } +} + +static void init_pins(void) { + unselect_cols(); + for (uint8_t x = 0; x < MATRIX_ROWS; x++) { + setPinInputHigh(row_pins[x]); + } +} + +static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col) { + bool matrix_changed = false; + + // Select col and wait for col selecton to stabilize + select_col(current_col); + wait_us(30); + + // For each row... + for (uint8_t row_index = 0; row_index < MATRIX_ROWS; row_index++) { + // Store last value of row prior to reading + matrix_row_t last_row_value = current_matrix[row_index]; + + // Check row pin state + if (readPin(row_pins[row_index]) == 0) { + // Pin LO, set col bit + current_matrix[row_index] |= (MATRIX_ROW_SHIFTER << current_col); + } else { + // Pin HI, clear col bit + current_matrix[row_index] &= ~(MATRIX_ROW_SHIFTER << current_col); + } + + // Determine if the matrix changed state + if ((last_row_value != current_matrix[row_index]) && !(matrix_changed)) { + matrix_changed = true; + } + } + + // Unselect col + unselect_col(current_col); + + return matrix_changed; +} + +#endif + +void matrix_init(void) { + // initialize key pins + init_pins(); + + // initialize matrix state: all keys off + for (uint8_t i = 0; i < MATRIX_ROWS; i++) { + raw_matrix[i] = 0; + matrix[i] = 0; + } + + debounce_init(MATRIX_ROWS); + + matrix_init_quantum(); +} + +uint8_t matrix_scan(void) { + bool changed = false; + +#if defined(DIRECT_PINS) || (DIODE_DIRECTION == COL2ROW) + // Set row, read cols + for (uint8_t current_row = 0; current_row < MATRIX_ROWS; current_row++) { + changed |= read_cols_on_row(raw_matrix, current_row); + } +#elif (DIODE_DIRECTION == ROW2COL) + // Set col, read rows + for (uint8_t current_col = 0; current_col < MATRIX_COLS; current_col++) { + changed |= read_rows_on_col(raw_matrix, current_col); + } +#endif + + debounce(raw_matrix, matrix, MATRIX_ROWS, changed); + + // Read encoder switches, already debounced + changed |= read_encoder_values(matrix, 4); + + matrix_scan_quantum(); + return (uint8_t)changed; +} + +// Customisations for the encoders +void matrix_init_kb(void){ + setPinInput(SWITCH_1); + setPinInput(SWITCH_2); +} + +void matrix_scan_kb(void){ + +} + +void matrix_print(void){ + +} + +static bool read_encoder_values(matrix_row_t current_matrix[], uint8_t current_row) { + // Store last value of row prior to reading + matrix_row_t last_row_value = current_matrix[current_row]; + + // Clear data in matrix row + current_matrix[current_row] = 0; + + // Debounce the encoder buttons using a shift register + static uint8_t btn_1_array; + static uint8_t btn_2_array; + bool btn_1_rising = 0; + bool btn_2_rising = 0; + btn_1_array <<= 1; + btn_2_array <<= 1; + btn_1_array |= readPin(SWITCH_1); + btn_2_array |= readPin(SWITCH_2); + (btn_1_array == 0b01111111) ? (btn_1_rising = 1) : (btn_1_rising = 0); + (btn_2_array == 0b01111111) ? (btn_2_rising = 1) : (btn_2_rising = 0); + + // Populate the matrix row with the state of the encoder + current_matrix[current_row] |= btn_1_rising ? (1 << 0) : 0; + current_matrix[current_row] |= btn_2_rising ? (1 << 1) : 0; + + return (last_row_value != current_matrix[current_row]); +} \ No newline at end of file diff --git a/keyboards/hub16/readme.md b/keyboards/hub16/readme.md new file mode 100755 index 000000000..996fa4463 --- /dev/null +++ b/keyboards/hub16/readme.md @@ -0,0 +1,15 @@ +# Hub16 + +Hub16 is a 16 Key Macro Pad with inbuilt USB 2.0 hub and dual rotary encoders. + +For more information regarding the keyboard, please visit the [Hub16 Webpage](https://www.joshajohnson.com/hub16-keyboard/) or [GitHub Repo](https://github.com/joshajohnson/Hub16). + +* Keyboard Maintainer: [Josh Johnson](https://github.com/joshajohnson) +* Hardware Supported: Hub16 PCB (atmega32u4) +* Hardware Availability: [Josh Johnson](https://www.joshajohnson.com/hub16-keyboard/) + +Make example for this keyboard (after setting up your build environment): + + make hub16: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). diff --git a/keyboards/hub16/rules.mk b/keyboards/hub16/rules.mk new file mode 100755 index 000000000..ad1e23860 --- /dev/null +++ b/keyboards/hub16/rules.mk @@ -0,0 +1,38 @@ +# MCU name +MCU = atmega32u4 + +# Bootloader selection +# Teensy halfkay +# Pro Micro caterina +# Atmel DFU atmel-dfu +# LUFA DFU lufa-dfu +# QMK DFU qmk-dfu +# ATmega32A bootloadHID +# ATmega328P USBasp +BOOTLOADER = caterina + +# Build Options +# change yes to no to disable +# +CUSTOM_MATRIX = yes # Custom scanning of matrix +BOOTMAGIC_ENABLE = no # Virtual DIP switch configuration +MOUSEKEY_ENABLE = no # Mouse keys +EXTRAKEY_ENABLE = yes # Audio control and System control +CONSOLE_ENABLE = yes # Console for debug +COMMAND_ENABLE = yes # Commands for debug and configuration +# Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE +SLEEP_LED_ENABLE = no # Breathing sleep LED during USB suspend +# if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work +NKRO_ENABLE = no # USB Nkey Rollover +BACKLIGHT_ENABLE = no # Enable keyboard backlight functionality +RGBLIGHT_ENABLE = yes # Enable keyboard RGB underglow +MIDI_ENABLE = no # MIDI support +UNICODE_ENABLE = no # Unicode +BLUETOOTH_ENABLE = no # Enable Bluetooth with the Adafruit EZ-Key HID +AUDIO_ENABLE = no # Audio output on port C6 +FAUXCLICKY_ENABLE = no # Use buzzer to emulate clicky switches +HD44780_ENABLE = no # Enable support for HD44780 based LCDs +ENCODER_ENABLE = yes # Rotary Encoder support +TAP_DANCE_ENABLE = yes # Support for tap dancing + +SRC = matrix.c