Nulo/qmk_firmware
1
0
Fork 0
Code Releases Activity

Remove deprecated callbacks for encoders and dip switches (#13404)

Browse source
This commit is contained in:
Drashna Jaelre 2021-07-24 00:37:19 -07:00 committed by GitHub
parent 73d4d7dc2b
commit b8a1e14f53
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
59 changed files with 338 additions and 458 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
docs/ja/feature_encoders.md
View file

@ -51,15 +51,18 @@ ENCODER_ENABLE = yes
コールバック関数を `<keyboard>.c` に記述することができます: コールバック関数を `<keyboard>.c` に記述することができます:
```c ```c
void encoder_update_kb(uint8_t index, bool clockwise) { bool encoder_update_kb(uint8_t index, bool clockwise) {
encoder_update_user(index, clockwise); if (!encoder_update_user(index, clockwise)) {
return false;
}
} }
``` ```
あるいは `keymap.c` に記述することもできます: あるいは `keymap.c` に記述することもできます:
```c ```c
void encoder_update_user(uint8_t index, bool clockwise) { bool encoder_update_user(uint8_t index, bool clockwise) {
if (index == 0) { /* First encoder */ if (index == 0) { /* First encoder */
if (clockwise) { if (clockwise) {
tap_code(KC_PGDN); tap_code(KC_PGDN);
@ -73,6 +76,7 @@ void encoder_update_user(uint8_t index, bool clockwise) {
tap_code(KC_UP); tap_code(KC_UP);
} }
} }
return true;
} }
``` ```

21
keyboards/gmmk/pro/ansi/keymaps/willwm/keymap.c
View file

@ -16,16 +16,15 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include QMK_KEYBOARD_H #include QMK_KEYBOARD_H
// clang-format off
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
// ESC F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 Del Rotary(Mute) // ESC F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 Del Rotary(Mute)
// ~ 1 2 3 4 5 6 7 8 9 0 - (=) BackSpc Home // ~ 1 2 3 4 5 6 7 8 9 0 - (=) BackSpc Home
// Tab Q W E R T Y U I O P [ ] \ PgUp // Tab Q W E R T Y U I O P [ ] \ PgUp
// Caps A S D F G H J K L ; " Enter PgDn // Caps A S D F G H J K L ; " Enter PgDn
// Sh_L Z X C V B N M , . ? Sh_R Up End // Sh_L Z X C V B N M , . ? Sh_R Up End
// Ct_L Win_L Alt_L SPACE Alt_R FN Ct_R Left Down Right // Ct_L Win_L Alt_L SPACE Alt_R FN Ct_R Left Down Right
[0] = LAYOUT( [0] = LAYOUT(
KC_ESC, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, KC_DEL, KC_MUTE, KC_ESC, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, KC_DEL, KC_MUTE,
KC_GRV, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_MINS, KC_EQL, KC_BSPC, KC_HOME, KC_GRV, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_MINS, KC_EQL, KC_BSPC, KC_HOME,
@ -61,14 +60,14 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______ _______, _______, _______, _______, _______, _______, _______, _______, _______, _______
), ),
}; };
// clang-format on
bool encoder_update_user(uint8_t index, bool clockwise) {
void encoder_update_user(uint8_t index, bool clockwise) {
if (clockwise) { if (clockwise) {
tap_code(KC_VOLU); tap_code(KC_VOLU);
} else { } else {
tap_code(KC_VOLD); tap_code(KC_VOLD);
} }
return true;
} }

2
keyboards/handwired/daishi/daishi.h
View file

@ -2,8 +2,6 @@
#include "quantum.h" #include "quantum.h"
#define encoder_update(clockwise) encoder_update_user(uint8_t index, clockwise)
// The first section contains all of the arguments // The first section contains all of the arguments
// The second converts the arguments into a two-dimensional array // The second converts the arguments into a two-dimensional array
#define LAYOUT( \ #define LAYOUT( \

2
keyboards/handwired/daishi/keymaps/default/keymap.c
View file

@ -82,7 +82,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
return true; return true;
}; };
bool encoder_update(bool clockwise) { bool encoder_update_user(uint8_t index, bool clockwise) {
if (clockwise) { if (clockwise) {
tap_code(KC_VOLU); tap_code(KC_VOLU);
} else { } else {

9
keyboards/hub20/keymaps/left_hand_numpad/keymap.c
View file

@ -15,15 +15,13 @@
*/ */
#include QMK_KEYBOARD_H #include QMK_KEYBOARD_H
// #define LED_MERGE_NUMPAD_LEFT_HANDED_PLUS TRUE // #define LED_MERGE_NUMPAD_LEFT_HANDED_PLUS TRUE
// #define LED_MERGE_NUMPAD_LEFT_HANDED_ENTER TRUE // #define LED_MERGE_NUMPAD_LEFT_HANDED_ENTER TRUE
// #define LED_MERGE_NUMPAD_LEFT_HANDED_ZERO TRUE // #define LED_MERGE_NUMPAD_LEFT_HANDED_ZERO TRUE
#define MO_NLCK LT(1, KC_NLCK) // Numlock on tap, layer change on hold #define MO_NLCK LT(1, KC_NLCK) // Numlock on tap, layer change on hold
// clang-format off
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
[0] = LAYOUT_left_handed( [0] = LAYOUT_left_handed(
KC_MUTE, KC_MPLY, KC_MUTE, KC_MPLY,
@ -42,8 +40,9 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
_______, _______ _______, _______
) )
}; };
// clang-format of
void encoder_update_user(uint8_t index, bool clockwise) { bool encoder_update_user(uint8_t index, bool clockwise) {
if (index == 0) { /* Left Encoder */ if (index == 0) { /* Left Encoder */
if (clockwise) { if (clockwise) {
tap_code(KC_VOLU); tap_code(KC_VOLU);
@ -57,5 +56,5 @@ void encoder_update_user(uint8_t index, bool clockwise) {
tap_code(KC_MPRV); tap_code(KC_MPRV);
} }
} }
return true;
} }

12
keyboards/hub20/keymaps/right_hand_numpad/keymap.c
View file

@ -15,15 +15,13 @@
*/ */
#include QMK_KEYBOARD_H #include QMK_KEYBOARD_H
// #define LED_MERGE_NUMPAD_RIGHT_HANDED_PLUS TRUE // #define LED_MERGE_NUMPAD_RIGHT_HANDED_PLUS TRUE
// #define LED_MERGE_NUMPAD_RIGHT_HANDED_ENTER TRUE // #define LED_MERGE_NUMPAD_RIGHT_HANDED_ENTER TRUE
// #define LED_MERGE_NUMPAD_RIGHT_HANDED_ZERO TRUE // #define LED_MERGE_NUMPAD_RIGHT_HANDED_ZERO TRUE
#define MO_NLCK LT(1, KC_NLCK) // Numlock on tap, layer change on hold #define MO_NLCK LT(1, KC_NLCK) // Numlock on tap, layer change on hold
// clang-format off
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
//NOT TESTED, WAITING ENDORSEMENT FROM MANUFACTURER //NOT TESTED, WAITING ENDORSEMENT FROM MANUFACTURER
@ -44,11 +42,9 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
_______, _______, _______ _______, _______, _______
) )
}; };
// clang-format on
bool encoder_update_user(uint8_t index, bool clockwise) {
void encoder_update_user(uint8_t index, bool clockwise) {
if (index == 0) { /* Left Encoder */ if (index == 0) { /* Left Encoder */
if (clockwise) { if (clockwise) {
tap_code(KC_VOLU); tap_code(KC_VOLU);
@ -62,5 +58,5 @@ void encoder_update_user(uint8_t index, bool clockwise) {
tap_code(KC_MPRV); tap_code(KC_MPRV);
} }
} }
return true;
} }

6
keyboards/manyboard/macro/keymaps/default/keymap.c
View file

@ -15,7 +15,7 @@
*/ */
#include QMK_KEYBOARD_H #include QMK_KEYBOARD_H
// clang-format off
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
[0] = LAYOUT_ortho_4x4( [0] = LAYOUT_ortho_4x4(
KC_F1, KC_F2, KC_F3, KC_F4, KC_F1, KC_F2, KC_F3, KC_F4,
@ -36,6 +36,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
KC_TRNS, KC_TRNS, KC_TRNS, TO(0) KC_TRNS, KC_TRNS, KC_TRNS, TO(0)
), ),
}; };
// clang-format on
layer_state_t layer_state_set_user(layer_state_t state) { layer_state_t layer_state_set_user(layer_state_t state) {
switch (get_highest_layer(state)) { switch (get_highest_layer(state)) {
@ -55,7 +56,7 @@ layer_state_t layer_state_set_user(layer_state_t state) {
return state; return state;
} }
void encoder_update_user(uint8_t index, bool clockwise) { bool encoder_update_user(uint8_t index, bool clockwise) {
/* With an if statement we can check which encoder was turned. */ /* With an if statement we can check which encoder was turned. */
if (index == 0) { /* First encoder */ if (index == 0) { /* First encoder */
/* And with another if statement we can check the direction. */ /* And with another if statement we can check the direction. */
@ -70,4 +71,5 @@ void encoder_update_user(uint8_t index, bool clockwise) {
tap_code(KC_AUDIO_VOL_DOWN); tap_code(KC_AUDIO_VOL_DOWN);
} }
} }
return true;
} }

7
keyboards/manyboard/macro/keymaps/via/keymap.c
View file

@ -15,7 +15,7 @@
*/ */
#include QMK_KEYBOARD_H #include QMK_KEYBOARD_H
// clang-format off
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
[0] = LAYOUT_ortho_4x4( [0] = LAYOUT_ortho_4x4(
KC_F1, KC_F2, KC_F3, KC_F4, KC_F1, KC_F2, KC_F3, KC_F4,
@ -36,6 +36,8 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
KC_TRNS, KC_TRNS, KC_TRNS, TO(0) KC_TRNS, KC_TRNS, KC_TRNS, TO(0)
), ),
}; };
// clang-format on
layer_state_t layer_state_set_user(layer_state_t state) { layer_state_t layer_state_set_user(layer_state_t state) {
switch (get_highest_layer(state)) { switch (get_highest_layer(state)) {
case 0: case 0:
@ -54,7 +56,7 @@ layer_state_t layer_state_set_user(layer_state_t state) {
return state; return state;
} }
void encoder_update_user(uint8_t index, bool clockwise) { bool encoder_update_user(uint8_t index, bool clockwise) {
/* With an if statement we can check which encoder was turned. */ /* With an if statement we can check which encoder was turned. */
if (index == 0) { /* First encoder */ if (index == 0) { /* First encoder */
/* And with another if statement we can check the direction. */ /* And with another if statement we can check the direction. */
@ -69,4 +71,5 @@ void encoder_update_user(uint8_t index, bool clockwise) {
tap_code(KC_AUDIO_VOL_DOWN); tap_code(KC_AUDIO_VOL_DOWN);
} }
} }
return true;
} }

12
keyboards/nullbitsco/nibble/keymaps/oled_status/keymap.c
View file

@ -19,15 +19,13 @@
# include "oled_display.h" # include "oled_display.h"
#endif #endif
enum layer_names { enum layer_names { _MA, _FN };
_MA,
_FN
};
enum custom_keycodes { enum custom_keycodes {
KC_CUST = SAFE_RANGE, KC_CUST = SAFE_RANGE,
}; };
// clang-format off
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
[_MA] = LAYOUT_ansi( [_MA] = LAYOUT_ansi(
KC_ESC, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_MINS, KC_EQL, KC_BSPC, KC_HOME, KC_ESC, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_MINS, KC_EQL, KC_BSPC, KC_HOME,
@ -44,6 +42,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______ _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______
), ),
}; };
// clang-format on
#ifdef OLED_DRIVER_ENABLE #ifdef OLED_DRIVER_ENABLE
oled_rotation_t oled_init_user(oled_rotation_t rotation) { oled_rotation_t oled_init_user(oled_rotation_t rotation) {
@ -64,7 +63,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
// Send keystrokes to host keyboard, if connected (see readme) // Send keystrokes to host keyboard, if connected (see readme)
process_record_remote_kb(keycode, record); process_record_remote_kb(keycode, record);
switch(keycode) { switch (keycode) {
case RGB_TOG: case RGB_TOG:
if (record->event.pressed) { if (record->event.pressed) {
#ifdef OLED_DRIVER_ENABLE #ifdef OLED_DRIVER_ENABLE
@ -72,7 +71,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#endif #endif
} }
break; break;
case KC_CUST: //custom macro case KC_CUST: // custom macro
if (record->event.pressed) { if (record->event.pressed) {
} }
break; break;
@ -80,7 +79,6 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
return true; return true;
} }
bool encoder_update_user(uint8_t index, bool clockwise) { bool encoder_update_user(uint8_t index, bool clockwise) {
if (clockwise) { if (clockwise) {
tap_code(KC_VOLU); tap_code(KC_VOLU);

3
keyboards/pearlboards/pandora/keymaps/default/keymap.c
View file

@ -71,7 +71,7 @@ bool encoder_update_user(uint8_t index, bool clockwise) {
return true; return true;
} }
// Encoder click function // Encoder click function
void dip_switch_update_user(uint8_t index, bool active) { bool dip_switch_update_user(uint8_t index, bool active) {
switch (index) { switch (index) {
/* First encoder */ /* First encoder */
case 0: case 0:
@ -80,4 +80,5 @@ void dip_switch_update_user(uint8_t index, bool active) {
} }
break; break;
} }
return true;
} }

3
keyboards/pearlboards/pandora/keymaps/via/keymap.c
View file

@ -85,7 +85,7 @@ bool encoder_update_user(uint8_t index, bool clockwise) {
return true; return true;
} }
// Encoder click function // Encoder click function
void dip_switch_update_user(uint8_t index, bool active) { bool dip_switch_update_user(uint8_t index, bool active) {
switch (index) { switch (index) {
/* First encoder */ /* First encoder */
case 0: case 0:
@ -94,4 +94,5 @@ void dip_switch_update_user(uint8_t index, bool active) {
} }
break; break;
} }
return true
} }

2
keyboards/planck/keymaps/abishalom/keymap.c
View file

@ -221,7 +221,7 @@ uint16_t muse_counter = 0;
uint8_t muse_offset = 70; uint8_t muse_offset = 70;
uint16_t muse_tempo = 50; uint16_t muse_tempo = 50;
bool encoder_update(bool clockwise) { bool encoder_update_user(uint8_t index, bool clockwise) {
if (muse_mode) { if (muse_mode) {
if (IS_LAYER_ON(_RAISE)) { if (IS_LAYER_ON(_RAISE)) {
if (clockwise) { if (clockwise) {

2
keyboards/planck/keymaps/atreus/keymap.c
View file

@ -144,7 +144,7 @@ uint16_t muse_counter = 0;
uint8_t muse_offset = 70; uint8_t muse_offset = 70;
uint16_t muse_tempo = 50; uint16_t muse_tempo = 50;
bool encoder_update(bool clockwise) { bool encoder_update_user(uint8_t index, bool clockwise) {
if (muse_mode) { if (muse_mode) {
if (IS_LAYER_ON(_RAISE)) { if (IS_LAYER_ON(_RAISE)) {
if (clockwise) { if (clockwise) {

2
keyboards/planck/keymaps/charlesrocket/keymap.c
View file

@ -139,7 +139,7 @@ uint16_t muse_counter = 0;
uint8_t muse_offset = 70; uint8_t muse_offset = 70;
uint16_t muse_tempo = 50; uint16_t muse_tempo = 50;
bool encoder_update(bool clockwise) { bool encoder_update_user(uint8_t index, bool clockwise) {
if (muse_mode) { if (muse_mode) {
if (IS_LAYER_ON(_RAISE)) { if (IS_LAYER_ON(_RAISE)) {
if (clockwise) { if (clockwise) {

2
keyboards/planck/keymaps/dear_vehicle_owner/keymap.c
View file

@ -263,7 +263,7 @@ uint16_t muse_counter = 0;
uint8_t muse_offset = 70; uint8_t muse_offset = 70;
uint16_t muse_tempo = 50; uint16_t muse_tempo = 50;
bool encoder_update(bool clockwise) { bool encoder_update_user(uint8_t index, bool clockwise) {
if (muse_mode) { if (muse_mode) {
if (IS_LAYER_ON(_RAISE)) { if (IS_LAYER_ON(_RAISE)) {
if (clockwise) { if (clockwise) {

2
keyboards/planck/keymaps/default/keymap.c
View file

@ -256,7 +256,7 @@ uint16_t muse_counter = 0;
uint8_t muse_offset = 70; uint8_t muse_offset = 70;
uint16_t muse_tempo = 50; uint16_t muse_tempo = 50;
bool encoder_update(bool clockwise) { bool encoder_update_user(uint8_t index, bool clockwise) {
if (muse_mode) { if (muse_mode) {
if (IS_LAYER_ON(_RAISE)) { if (IS_LAYER_ON(_RAISE)) {
if (clockwise) { if (clockwise) {

2
keyboards/planck/keymaps/eshesh2/keymap.c
View file

@ -187,7 +187,7 @@ uint16_t muse_counter = 0;
uint8_t muse_offset = 70; uint8_t muse_offset = 70;
uint16_t muse_tempo = 50; uint16_t muse_tempo = 50;
bool encoder_update(bool clockwise) { bool encoder_update_user(uint8_t index, bool clockwise) {
if (muse_mode) { if (muse_mode) {
if (IS_LAYER_ON(_RAISE)) { if (IS_LAYER_ON(_RAISE)) {
if (clockwise) { if (clockwise) {

4
keyboards/planck/keymaps/fabian/keymap.c
View file

@ -265,7 +265,7 @@ uint16_t muse_counter = 0;
uint8_t muse_offset = 70; uint8_t muse_offset = 70;
uint16_t muse_tempo = 50; uint16_t muse_tempo = 50;
bool encoder_update(bool clockwise) { bool encoder_update_user(uint8_t index, bool clockwise) {
if (muse_mode) { if (muse_mode) {
if (IS_LAYER_ON(_RAISE)) { if (IS_LAYER_ON(_RAISE)) {
if (clockwise) { if (clockwise) {
@ -291,7 +291,7 @@ bool encoder_update(bool clockwise) {
} }
} }
void dip_update(uint8_t index, bool active) { bool dip_switch_update_user(uint8_t index, bool active) {
switch (index) { switch (index) {
case 0: case 0:
if (active) { if (active) {

2
keyboards/planck/keymaps/gitdrik/keymap.c
View file

@ -137,7 +137,7 @@ uint16_t muse_counter = 0;
uint8_t muse_offset = 70; uint8_t muse_offset = 70;
uint16_t muse_tempo = 50; uint16_t muse_tempo = 50;
bool encoder_update(bool clockwise) { bool encoder_update_user(uint8_t index, bool clockwise) {
if (muse_mode) { if (muse_mode) {
if (IS_LAYER_ON(_RIGHT)) { if (IS_LAYER_ON(_RIGHT)) {
if (clockwise) { if (clockwise) {

2
keyboards/planck/keymaps/grant24/keymap.c
View file

@ -279,7 +279,7 @@ uint16_t muse_counter = 0;
uint8_t muse_offset = 70; uint8_t muse_offset = 70;
uint16_t muse_tempo = 50; uint16_t muse_tempo = 50;
bool encoder_update(bool clockwise) { bool encoder_update_user(uint8_t index, bool clockwise) {
if (muse_mode) { if (muse_mode) {
if (IS_LAYER_ON(_RAISE)) { if (IS_LAYER_ON(_RAISE)) {
if (clockwise) { if (clockwise) {

2
keyboards/planck/keymaps/hvp/keymap.c
View file

@ -89,7 +89,7 @@ uint16_t muse_counter = 0;
uint8_t muse_offset = 70; uint8_t muse_offset = 70;
uint16_t muse_tempo = 50; uint16_t muse_tempo = 50;
bool encoder_update(bool clockwise) { bool encoder_update_user(uint8_t index, bool clockwise) {
if (muse_mode) { if (muse_mode) {
if (IS_LAYER_ON(_RAISE)) { if (IS_LAYER_ON(_RAISE)) {
if (clockwise) { if (clockwise) {

3
keyboards/planck/keymaps/jdelkins/keymap.c
View file

@ -259,7 +259,7 @@ uint16_t muse_counter = 0;
uint8_t muse_offset = 70; uint8_t muse_offset = 70;
uint16_t muse_tempo = 50; uint16_t muse_tempo = 50;
void encoder_update(bool clockwise) { bool encoder_update_user(uint8_t index, bool clockwise) {
if (muse_mode) { if (muse_mode) {
if (IS_LAYER_ON(_RAISE)) { if (IS_LAYER_ON(_RAISE)) {
if (clockwise) { if (clockwise) {
@ -289,6 +289,7 @@ void encoder_update(bool clockwise) {
#endif #endif
} }
} }
return true;
} }
bool dip_switch_update_user(uint8_t index, bool active) { bool dip_switch_update_user(uint8_t index, bool active) {

5
keyboards/planck/keymaps/jetpacktuxedo/keymap.c
View file

@ -190,7 +190,7 @@ uint16_t muse_tempo = 20;
extern float clicky_rand; extern float clicky_rand;
bool encoder_update(bool clockwise) { bool encoder_update_user(uint8_t index, bool clockwise) {
if (is_clicky_on()) { if (is_clicky_on()) {
if (IS_LAYER_ON(_RAISE)) { if (IS_LAYER_ON(_RAISE)) {
if (clockwise) { if (clockwise) {
@ -241,7 +241,7 @@ bool encoder_update(bool clockwise) {
return true; return true;
} }
void dip_update(uint8_t index, bool active) { bool dip_switch_update_user(uint8_t index, bool active) {
switch (index) { switch (index) {
case 0: case 0:
if (active) { if (active) {
@ -273,6 +273,7 @@ void dip_update(uint8_t index, bool active) {
clicky_off(); clicky_off();
} }
} }
return true;
} }
void matrix_scan_user(void) { void matrix_scan_user(void) {

2
keyboards/planck/keymaps/lja83/keymap.c
View file

@ -266,7 +266,7 @@ uint16_t muse_counter = 0;
uint8_t muse_offset = 70; uint8_t muse_offset = 70;
uint16_t muse_tempo = 50; uint16_t muse_tempo = 50;
bool encoder_update_user(uint16_t index, bool clockwise) { bool encoder_update_user(uint8_t index, bool clockwise) {
if (muse_mode) { if (muse_mode) {
if (IS_LAYER_ON(_RAISE)) { if (IS_LAYER_ON(_RAISE)) {
if (clockwise) { if (clockwise) {

4
keyboards/planck/keymaps/mgalisa/keymap.c
View file

@ -317,7 +317,7 @@ uint16_t muse_counter = 0;
uint8_t muse_offset = 70; uint8_t muse_offset = 70;
uint16_t muse_tempo = 50; uint16_t muse_tempo = 50;
bool encoder_update(bool clockwise) { bool encoder_update_user(uint8_t index, bool clockwise) {
if (muse_mode) { if (muse_mode) {
if (IS_LAYER_ON(_RAISE)) { if (IS_LAYER_ON(_RAISE)) {
if (clockwise) { if (clockwise) {
@ -350,7 +350,7 @@ bool encoder_update(bool clockwise) {
return true; return true;
} }
void dip_update(uint8_t index, bool active) { bool dip_switch_update_user(uint8_t index, bool active) {
switch (index) { switch (index) {
case 0: case 0:
if (active) { if (active) {

5
keyboards/planck/keymaps/mikethetiger/keymap.c
View file

@ -256,7 +256,7 @@ uint16_t muse_counter = 0;
uint8_t muse_offset = 70; uint8_t muse_offset = 70;
uint16_t muse_tempo = 50; uint16_t muse_tempo = 50;
bool encoder_update(bool clockwise) { bool encoder_update_user(uint8_t index, bool clockwise) {
if (muse_mode) { if (muse_mode) {
if (IS_LAYER_ON(_RAISE)) { if (IS_LAYER_ON(_RAISE)) {
if (clockwise) { if (clockwise) {
@ -293,7 +293,7 @@ bool encoder_update(bool clockwise) {
return true; return true;
} }
void dip_update(uint8_t index, bool active) { bool dip_switch_update_user(uint8_t index, bool active) {
switch (index) { switch (index) {
case 0: case 0:
if (active) { if (active) {
@ -318,6 +318,7 @@ void dip_update(uint8_t index, bool active) {
#endif #endif
} }
} }
return true;
} }
void matrix_scan_user(void) { void matrix_scan_user(void) {

5
keyboards/planck/keymaps/msiu/keymap.c
View file

@ -128,7 +128,7 @@ uint16_t muse_counter = 0;
uint8_t muse_offset = 70; uint8_t muse_offset = 70;
uint16_t muse_tempo = 50; uint16_t muse_tempo = 50;
bool encoder_update(bool clockwise) { bool encoder_update_user(uint8_t index, bool clockwise) {
if (muse_mode) { if (muse_mode) {
if (IS_LAYER_ON(_RAISE)) { if (IS_LAYER_ON(_RAISE)) {
if (clockwise) { if (clockwise) {
@ -155,7 +155,7 @@ bool encoder_update(bool clockwise) {
return true; return true;
} }
void dip_update(uint8_t index, bool active) { bool dip_switch_update_user(uint8_t index, bool active) {
switch (index) { switch (index) {
case 0: case 0:
if (active) { if (active) {
@ -180,6 +180,7 @@ void dip_update(uint8_t index, bool active) {
#endif #endif
} }
} }
return true;
} }
void matrix_scan_user(void) { void matrix_scan_user(void) {

7
keyboards/planck/keymaps/muzfuz/keymap.c
View file

@ -177,8 +177,7 @@ uint16_t muse_counter = 0;
uint8_t muse_offset = 70; uint8_t muse_offset = 70;
uint16_t muse_tempo = 50; uint16_t muse_tempo = 50;
bool encoder_update(bool clockwise) bool encoder_update_user(uint8_t index, bool clockwise) {
{
if (muse_mode) if (muse_mode)
{ {
if (IS_LAYER_ON(_RAISE)) if (IS_LAYER_ON(_RAISE))
@ -230,8 +229,7 @@ bool encoder_update(bool clockwise)
return true; return true;
} }
void dip_update(uint8_t index, bool active) bool encoder_update_user(uint8_t index, bool clockwise) {
{
switch (index) switch (index)
{ {
case 0: case 0:
@ -263,6 +261,7 @@ void dip_update(uint8_t index, bool active)
#endif #endif
} }
} }
return true;
} }
void matrix_scan_user(void) void matrix_scan_user(void)

2
keyboards/planck/keymaps/navi/keymap.c
View file

@ -170,7 +170,7 @@ uint16_t muse_counter = 0;
uint8_t muse_offset = 70; uint8_t muse_offset = 70;
uint16_t muse_tempo = 50; uint16_t muse_tempo = 50;
bool encoder_update(bool clockwise) { bool encoder_update_user(uint8_t index, bool clockwise) {
if (muse_mode) { if (muse_mode) {
if (IS_LAYER_ON(_RAISE)) { if (IS_LAYER_ON(_RAISE)) {
if (clockwise) { if (clockwise) {

2
keyboards/planck/keymaps/nick/keymap.c
View file

@ -109,7 +109,7 @@ layer_state_t layer_state_set_user(layer_state_t state) {
return update_tri_layer_state(state, _LOWER, _RAISE, _ADJUST); return update_tri_layer_state(state, _LOWER, _RAISE, _ADJUST);
} }
bool encoder_update(bool clockwise) { bool encoder_update_user(uint8_t index, bool clockwise) {
if (clockwise && !IS_LAYER_ON(_RAISE)) { if (clockwise && !IS_LAYER_ON(_RAISE)) {
tap_code(KC_MS_WH_DOWN); tap_code(KC_MS_WH_DOWN);
} else if (!clockwise && !IS_LAYER_ON(_RAISE)) { } else if (!clockwise && !IS_LAYER_ON(_RAISE)) {

2
keyboards/planck/keymaps/oryx/keymap.c
View file

@ -319,7 +319,7 @@ uint16_t muse_counter = 0;
uint8_t muse_offset = 70; uint8_t muse_offset = 70;
uint16_t muse_tempo = 50; uint16_t muse_tempo = 50;
bool encoder_update(bool clockwise) { bool encoder_update_user(uint8_t index, bool clockwise) {
if (muse_mode) { if (muse_mode) {
if (IS_LAYER_ON(_RAISE)) { if (IS_LAYER_ON(_RAISE)) {
if (clockwise) { if (clockwise) {

5
keyboards/planck/keymaps/pascamel/keymap.c
View file

@ -157,7 +157,7 @@ uint16_t muse_counter = 0;
uint8_t muse_offset = 70; uint8_t muse_offset = 70;
uint16_t muse_tempo = 50; uint16_t muse_tempo = 50;
bool encoder_update(bool clockwise) { bool encoder_update_user(uint8_t index, bool clockwise) {
if (muse_mode) { if (muse_mode) {
if (IS_LAYER_ON(_RAISE)) { if (IS_LAYER_ON(_RAISE)) {
if (clockwise) { if (clockwise) {
@ -184,7 +184,7 @@ bool encoder_update(bool clockwise) {
return true; return true;
} }
void dip_update(uint8_t index, bool active) { bool dip_switch_update_user(uint8_t index, bool active) {
switch (index) { switch (index) {
case 0: case 0:
if (active) { if (active) {
@ -209,6 +209,7 @@ void dip_update(uint8_t index, bool active) {
#endif #endif
} }
} }
return true;
} }
void matrix_scan_user(void) { void matrix_scan_user(void) {

7
keyboards/planck/keymaps/pevecyan/keymap.c
View file

@ -132,7 +132,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
* | | | | | | | | | | | | * | | | | | | | | | | | |
* `-----------------------------------------------------------------------------------' * `-----------------------------------------------------------------------------------'
*/ */
[_ALTGR] = LAYOUT_planck_grid(k [_ALTGR] = LAYOUT_planck_grid(
_______, SI_BSLS, SI_PIPE, SI_EURO, _______, _______, _______, _______, _______, _______, _______, _______, _______, SI_BSLS, SI_PIPE, SI_EURO, _______, _______, _______, _______, _______, _______, _______, _______,
_______, _______, _______, _______, SI_LBRC, SI_RBRC, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, SI_LBRC, SI_RBRC, _______, _______, _______, _______, _______, _______,
_______, _______, _______, _______, SI_AT, SI_LCBR, SI_RCBR, _______, SI_LABK, SI_RABK, _______, _______, _______, _______, _______, _______, SI_AT, SI_LCBR, SI_RCBR, _______, SI_LABK, SI_RABK, _______, _______,
@ -178,7 +178,7 @@ uint16_t muse_counter = 0;
uint8_t muse_offset = 70; uint8_t muse_offset = 70;
uint16_t muse_tempo = 50; uint16_t muse_tempo = 50;
bool encoder_update(bool clockwise) { bool encoder_update_user(uint8_t index, bool clockwise) {
if (muse_mode) { if (muse_mode) {
if (IS_LAYER_ON(_RAISE)) { if (IS_LAYER_ON(_RAISE)) {
if (clockwise) { if (clockwise) {
@ -205,7 +205,7 @@ bool encoder_update(bool clockwise) {
return true; return true;
} }
void dip_update(uint8_t index, bool active) { bool dip_switch_update_user(uint8_t index, bool active) {
switch (index) { switch (index) {
case 0: case 0:
if (active) { if (active) {
@ -230,6 +230,7 @@ void dip_update(uint8_t index, bool active) {
#endif #endif
} }
} }
return true;
} }
void matrix_scan_user(void) { void matrix_scan_user(void) {

5
keyboards/planck/keymaps/ptillemans/keymap.c
View file

@ -232,7 +232,7 @@ uint16_t muse_counter = 0;
uint8_t muse_offset = 70; uint8_t muse_offset = 70;
uint16_t muse_tempo = 50; uint16_t muse_tempo = 50;
bool encoder_update(bool clockwise) { bool encoder_update_user(uint8_t index, bool clockwise) {
if (muse_mode) { if (muse_mode) {
if (IS_LAYER_ON(_RAISE)) { if (IS_LAYER_ON(_RAISE)) {
if (clockwise) { if (clockwise) {
@ -269,7 +269,7 @@ bool encoder_update(bool clockwise) {
return true; return true;
} }
void dip_update(uint8_t index, bool active) { bool dip_switch_update_user(uint8_t index, bool active) {
switch (index) { switch (index) {
case 0: case 0:
if (active) { if (active) {
@ -294,6 +294,7 @@ void dip_update(uint8_t index, bool active) {
#endif #endif
} }
} }
return true;
} }
void matrix_scan_user(void) { void matrix_scan_user(void) {

5
keyboards/planck/keymaps/raffle/keymap.c
View file

@ -223,7 +223,7 @@ uint16_t muse_counter = 0;
uint8_t muse_offset = 70; uint8_t muse_offset = 70;
uint16_t muse_tempo = 50; uint16_t muse_tempo = 50;
bool encoder_update(bool clockwise) { bool encoder_update_user(uint8_t index, bool clockwise) {
if (muse_mode) { if (muse_mode) {
if (IS_LAYER_ON(_RAISE)) { if (IS_LAYER_ON(_RAISE)) {
if (clockwise) { if (clockwise) {
@ -250,7 +250,7 @@ bool encoder_update(bool clockwise) {
return true; return true;
} }
void dip_update(uint8_t index, bool active) { bool dip_switch_update_user(uint8_t index, bool active) {
switch (index) { switch (index) {
case 0: case 0:
if (active) { if (active) {
@ -275,6 +275,7 @@ void dip_update(uint8_t index, bool active) {
#endif #endif
} }
} }
return true;
} }
void matrix_scan_user(void) { void matrix_scan_user(void) {

2
keyboards/planck/keymaps/rjhilgefort/keymap.c
View file

@ -154,7 +154,7 @@ uint16_t muse_counter = 0;
uint8_t muse_offset = 70; uint8_t muse_offset = 70;
uint16_t muse_tempo = 50; uint16_t muse_tempo = 50;
bool encoder_update(bool clockwise) { bool encoder_update_user(uint8_t index, bool clockwise) {
if (muse_mode) { if (muse_mode) {
if (IS_LAYER_ON(_RAISE)) { if (IS_LAYER_ON(_RAISE)) {
if (clockwise) { if (clockwise) {

2
keyboards/planck/keymaps/sigul/keymap.c
View file

@ -162,7 +162,7 @@ uint16_t muse_counter = 0;
uint8_t muse_offset = 70; uint8_t muse_offset = 70;
uint16_t muse_tempo = 50; uint16_t muse_tempo = 50;
bool encoder_update(bool clockwise) { bool encoder_update_user(uint8_t index, bool clockwise) {
if (muse_mode) { if (muse_mode) {
if (IS_LAYER_ON(_RAISE)) { if (IS_LAYER_ON(_RAISE)) {
if (clockwise) { if (clockwise) {

5
keyboards/planck/keymaps/skug/keymap.c
View file

@ -264,7 +264,7 @@ uint16_t muse_counter = 0;
uint8_t muse_offset = 70; uint8_t muse_offset = 70;
uint16_t muse_tempo = 50; uint16_t muse_tempo = 50;
bool encoder_update(bool clockwise) { bool encoder_update_user(uint8_t index, bool clockwise) {
if (muse_mode) { if (muse_mode) {
if (IS_LAYER_ON(_RAISE)) { if (IS_LAYER_ON(_RAISE)) {
if (clockwise) { if (clockwise) {
@ -291,7 +291,7 @@ bool encoder_update(bool clockwise) {
return true; return true;
} }
void dip_update(uint8_t index, bool active) { bool dip_switch_update_user(uint8_t index, bool active) {
switch (index) { switch (index) {
case 0: case 0:
if (active) { if (active) {
@ -316,6 +316,7 @@ void dip_update(uint8_t index, bool active) {
#endif #endif
} }
} }
return true;
} }
void matrix_scan_user(void) { void matrix_scan_user(void) {

5
keyboards/planck/keymaps/smittey/keymap.c
View file

@ -297,7 +297,7 @@ uint16_t muse_counter = 0;
uint8_t muse_offset = 70; uint8_t muse_offset = 70;
uint16_t muse_tempo = 50; uint16_t muse_tempo = 50;
bool encoder_update(bool clockwise) { bool encoder_update_user(uint8_t index, bool clockwise) {
if (muse_mode) { if (muse_mode) {
if (IS_LAYER_ON(_RAISE)) { if (IS_LAYER_ON(_RAISE)) {
if (clockwise) { if (clockwise) {
@ -322,7 +322,7 @@ bool encoder_update(bool clockwise) {
return true; return true;
} }
void dip_update(uint8_t index, bool active) { bool dip_switch_update_user(uint8_t index, bool active) {
switch (index) { switch (index) {
case 0: case 0:
if (active) { if (active) {
@ -347,6 +347,7 @@ void dip_update(uint8_t index, bool active) {
#endif #endif
} }
} }
return true;
} }
void matrix_scan_user(void) { void matrix_scan_user(void) {

2
keyboards/planck/keymaps/synth_sample/keymap.c
View file

@ -247,7 +247,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
return true; return true;
} }
bool encoder_update(bool clockwise) { bool encoder_update_user(uint8_t index, bool clockwise) {
if (clockwise) { if (clockwise) {
#ifdef MOUSEKEY_ENABLE #ifdef MOUSEKEY_ENABLE
register_code(KC_MS_WH_DOWN); register_code(KC_MS_WH_DOWN);

2
keyboards/planck/keymaps/synth_wavetable/keymap.c
View file

@ -308,7 +308,7 @@ uint16_t dac_value_generate(void) {
return value; return value;
} }
bool encoder_update(bool clockwise) { bool encoder_update_user(uint8_t index, bool clockwise) {
if (clockwise) { if (clockwise) {
dac_morph = (dac_morph + 1) % AUDIO_DAC_WAVETABLE_CUSTOM_LENGTH; dac_morph = (dac_morph + 1) % AUDIO_DAC_WAVETABLE_CUSTOM_LENGTH;
} else { } else {

5
keyboards/planck/keymaps/tom/keymap.c
View file

@ -139,7 +139,7 @@ uint16_t muse_counter = 0;
uint8_t muse_offset = 70; uint8_t muse_offset = 70;
uint16_t muse_tempo = 50; uint16_t muse_tempo = 50;
bool encoder_update(bool clockwise) { bool encoder_update_user(uint8_t index, bool clockwise) {
if (muse_mode) { if (muse_mode) {
if (IS_LAYER_ON(_RAISE)) { if (IS_LAYER_ON(_RAISE)) {
if (clockwise) { if (clockwise) {
@ -172,7 +172,7 @@ bool encoder_update(bool clockwise) {
return true; return true;
} }
void dip_update(uint8_t index, bool active) { bool dip_switch_update_user(uint8_t index, bool active) {
switch (index) { switch (index) {
case 0: case 0:
if (active) { if (active) {
@ -197,6 +197,7 @@ void dip_update(uint8_t index, bool active) {
#endif #endif
} }
} }
return true;
} }
void matrix_scan_user(void) { void matrix_scan_user(void) {

2
keyboards/planck/keymaps/tylerwince/keymap.c
View file

@ -215,7 +215,7 @@ uint16_t muse_counter = 0;
uint8_t muse_offset = 70; uint8_t muse_offset = 70;
uint16_t muse_tempo = 50; uint16_t muse_tempo = 50;
bool encoder_update(bool clockwise) { bool encoder_update_user(uint8_t index, bool clockwise) {
if (muse_mode) { if (muse_mode) {
if (IS_LAYER_ON(_RAISE)) { if (IS_LAYER_ON(_RAISE)) {
if (clockwise) { if (clockwise) {

5
keyboards/planck/keymaps/unagi/keymap.c
View file

@ -267,7 +267,7 @@ uint16_t muse_counter = 0;
uint8_t muse_offset = 70; uint8_t muse_offset = 70;
uint16_t muse_tempo = 50; uint16_t muse_tempo = 50;
bool encoder_update(bool clockwise) { bool encoder_update_user(uint8_t index, bool clockwise) {
if (muse_mode) { if (muse_mode) {
if (IS_LAYER_ON(_RAISE)) { if (IS_LAYER_ON(_RAISE)) {
if (clockwise) { if (clockwise) {
@ -294,7 +294,7 @@ bool encoder_update(bool clockwise) {
return true; return true;
} }
void dip_update(uint8_t index, bool active) { bool dip_switch_update_user(uint8_t index, bool active) {
switch (index) { switch (index) {
case 0: case 0:
if (active) { if (active) {
@ -319,6 +319,7 @@ void dip_update(uint8_t index, bool active) {
#endif #endif
} }
} }
return true;
} }
void matrix_scan_user(void) { void matrix_scan_user(void) {

3
keyboards/planck/keymaps/winternebs/keymap.c
View file

@ -149,7 +149,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
return true; return true;
} }
void dip_update(uint8_t index, bool active) { bool dip_switch_update_user(uint8_t index, bool active) {
switch (index) { switch (index) {
case 0: case 0:
if (active) { if (active) {
@ -159,4 +159,5 @@ void dip_update(uint8_t index, bool active) {
} }
break; break;
} }
return true;
} }

2
keyboards/planck/planck.h
View file

@ -3,8 +3,6 @@
#include "quantum.h" #include "quantum.h"
#define encoder_update(clockwise) encoder_update_user(uint8_t index, clockwise)
#if defined(KEYBOARD_planck_ez) #if defined(KEYBOARD_planck_ez)
#include "ez.h" #include "ez.h"
#elif defined(KEYBOARD_planck_light) #elif defined(KEYBOARD_planck_light)

27
keyboards/planck/rev6/rev6.c
View file

@ -40,31 +40,4 @@ led_config_t g_led_config = { {
// 0 // 0
// 7 8 1 2 // 7 8 1 2
void suspend_power_down_kb(void) {
rgb_matrix_set_suspend_state(true);
suspend_power_down_user();
}
void suspend_wakeup_init_kb(void) {
rgb_matrix_set_suspend_state(false);
suspend_wakeup_init_user();
}
#endif
void matrix_init_kb(void) {
matrix_init_user();
}
void matrix_scan_kb(void) {
matrix_scan_user();
}
#ifdef DIP_SWITCH_ENABLE
__attribute__((weak))
bool dip_update(uint8_t index, bool active) { return true; }
__attribute__((weak))
bool dip_switch_update_user(uint8_t index, bool active) {
return dip_update(index, active);
}
#endif #endif

3
keyboards/preonic/keymaps/cranium/keymap.c
View file

@ -175,7 +175,7 @@ bool encoder_update_user(uint8_t index, bool clockwise) {
return true; return true;
} }
void dip_update(uint8_t index, bool active) { bool dip_switch_update_user(uint8_t index, bool active) {
switch (index) { switch (index) {
case 0: case 0:
if (active) { if (active) {
@ -191,6 +191,7 @@ void dip_update(uint8_t index, bool active) {
muse_mode = false; muse_mode = false;
} }
} }
return true;
} }
void matrix_scan_user(void) { void matrix_scan_user(void) {

3
keyboards/preonic/keymaps/fsck/keymap.c
View file

@ -202,7 +202,7 @@ bool encoder_update_user(uint8_t index, bool clockwise) {
return true; return true;
} }
void dip_update(uint8_t index, bool active) { bool dip_switch_update_user(uint8_t index, bool active) {
switch (index) { switch (index) {
case 0: case 0:
if (active) { if (active) {
@ -221,6 +221,7 @@ void dip_update(uint8_t index, bool active) {
#endif #endif
} }
} }
return true;
} }
void matrix_scan_user(void) { void matrix_scan_user(void) {

3
keyboards/preonic/keymaps/mikethetiger/keymap.c
View file

@ -242,7 +242,7 @@ bool encoder_update_user(uint8_t index, bool clockwise) {
return true; return true;
} }
void dip_update(uint8_t index, bool active) { bool dip_switch_update_user(uint8_t index, bool active) {
switch (index) { switch (index) {
case 0: case 0:
if (active) { if (active) {
@ -261,6 +261,7 @@ void dip_update(uint8_t index, bool active) {
#endif #endif
} }
} }
return true;
} }
void matrix_scan_user(void) { void matrix_scan_user(void) {

5
keyboards/preonic/keymaps/muzfuz/keymap.c
View file

@ -197,7 +197,7 @@ uint16_t muse_counter = 0;
uint8_t muse_offset = 70; uint8_t muse_offset = 70;
uint16_t muse_tempo = 50; uint16_t muse_tempo = 50;
bool encoder_update(bool clockwise) { bool encoder_update_user(uint8_t index, bool clockwise) {
if (muse_mode) { if (muse_mode) {
if (IS_LAYER_ON(_RAISE)) { if (IS_LAYER_ON(_RAISE)) {
if (clockwise) { if (clockwise) {
@ -224,7 +224,7 @@ bool encoder_update(bool clockwise) {
return true; return true;
} }
void dip_update(uint8_t index, bool active) { bool dip_switch_update_user(uint8_t index, bool active) {
switch (index) { switch (index) {
case 0: case 0:
if (active) { if (active) {
@ -243,6 +243,7 @@ void dip_update(uint8_t index, bool active) {
#endif #endif
} }
} }
return true;
} }
void matrix_scan_user(void) { void matrix_scan_user(void) {

3
keyboards/preonic/keymaps/xulkal/keymap.c
View file

@ -101,7 +101,7 @@ bool encoder_update_user(uint8_t index, bool clockwise) {
return true; return true;
} }
void dip_update(uint8_t index, bool active) { bool dip_switch_update_user(uint8_t index, bool active) {
switch (index) { switch (index) {
case 0: case 0:
if (active) { if (active) {
@ -120,6 +120,7 @@ void dip_update(uint8_t index, bool active) {
#endif #endif
} }
} }
return true
} }
void matrix_scan_user(void) { void matrix_scan_user(void) {

17
keyboards/preonic/rev3/rev3.c
View file

@ -43,23 +43,6 @@ led_config_t g_led_config = { {
// 7 8 1 2 // 7 8 1 2
#endif #endif
void matrix_init_kb(void) {
matrix_init_user();
}
void matrix_scan_kb(void) {
matrix_scan_user();
}
#ifdef DIP_SWITCH_ENABLE
__attribute__((weak))
bool dip_update(uint8_t index, bool active) { return true;}
__attribute__((weak))
bool dip_switch_update_user(uint8_t index, bool active) {
return dip_update(index, active);
}
#endif
#ifdef SWAP_HANDS_ENABLE #ifdef SWAP_HANDS_ENABLE
__attribute__ ((weak)) __attribute__ ((weak))

201
keyboards/sofle/keymaps/helltm/keymap.c
View file

@ -1,4 +1,4 @@
/* Copyright 2021 HellSingCoder /* Copyright 2021 HellSingCoder
* *
* 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
@ -25,6 +25,7 @@ enum sofle_layers {
_ADJUST, _ADJUST,
}; };
// clang-format off
enum custom_keycodes { enum custom_keycodes {
KC_QWERTY = SAFE_RANGE, KC_QWERTY = SAFE_RANGE,
KC_GAMING, KC_GAMING,
@ -40,9 +41,8 @@ enum custom_keycodes {
KC_LAYER KC_LAYER
}; };
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
/* /*
* QWERTY * QWERTY
* ,-----------------------------------------. ,-----------------------------------------. * ,-----------------------------------------. ,-----------------------------------------.
* | Esc | 1 | 2 | 3 | 4 | 5 | | 6 | 7 | 8 | 9 | 0 | BS | * | Esc | 1 | 2 | 3 | 4 | 5 | | 6 | 7 | 8 | 9 | 0 | BS |
@ -155,39 +155,21 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______ _______, _______, _______, _______, _______, _______, _______, _______, _______, _______
) )
}; };
// clang-format on
#ifdef OLED_DRIVER_ENABLE #ifdef OLED_DRIVER_ENABLE
/* 32 * 32 logo */ /* 32 * 32 logo */
static void render_logo(void) { static void render_logo(void) {
static const char PROGMEM hell_logo[] = { static const char PROGMEM hell_logo[] = {0x00, 0x80, 0xc0, 0xc0, 0x60, 0x60, 0x30, 0x30, 0x18, 0x1c, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x80, 0xe0, 0x78, 0x1e, 0x06, 0x00, 0x0c, 0x1c, 0x18, 0x30, 0x30, 0x60, 0x60, 0xc0, 0xc0, 0x80, 0x00, 0x01, 0x03, 0x07, 0x06, 0x0c, 0x0c, 0x18, 0x18, 0x30, 0x70, 0x60, 0x00, 0xc0, 0xf0, 0x3c, 0x0f, 0x03, 0x00, 0x00, 0x00, 0x00, 0x60, 0x70, 0x30, 0x18, 0x18, 0x0c, 0x0c, 0x06, 0x07, 0x03, 0x01, 0x00, 0xf8, 0xf8, 0x80, 0x80, 0x80, 0xf8, 0xf8, 0x00, 0x80, 0xc0, 0xc0, 0x40, 0xc0, 0xc0, 0x80, 0x00, 0xf8, 0xf8, 0x00, 0xf8, 0xf8, 0x00, 0x08, 0x38, 0x08, 0x00, 0x38, 0x08, 0x30, 0x08, 0x38, 0x00, 0x1f, 0x1f, 0x01, 0x01, 0x01, 0x1f, 0x1f, 0x00, 0x0f, 0x1f, 0x1a, 0x12, 0x1a, 0x1b, 0x0b, 0x00, 0x1f, 0x1f, 0x00, 0x1f, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
0x00, 0x80, 0xc0, 0xc0, 0x60, 0x60, 0x30, 0x30, 0x18, 0x1c, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x80,
0xe0, 0x78, 0x1e, 0x06, 0x00, 0x0c, 0x1c, 0x18, 0x30, 0x30, 0x60, 0x60, 0xc0, 0xc0, 0x80, 0x00,
0x01, 0x03, 0x07, 0x06, 0x0c, 0x0c, 0x18, 0x18, 0x30, 0x70, 0x60, 0x00, 0xc0, 0xf0, 0x3c, 0x0f,
0x03, 0x00, 0x00, 0x00, 0x00, 0x60, 0x70, 0x30, 0x18, 0x18, 0x0c, 0x0c, 0x06, 0x07, 0x03, 0x01,
0x00, 0xf8, 0xf8, 0x80, 0x80, 0x80, 0xf8, 0xf8, 0x00, 0x80, 0xc0, 0xc0, 0x40, 0xc0, 0xc0, 0x80,
0x00, 0xf8, 0xf8, 0x00, 0xf8, 0xf8, 0x00, 0x08, 0x38, 0x08, 0x00, 0x38, 0x08, 0x30, 0x08, 0x38,
0x00, 0x1f, 0x1f, 0x01, 0x01, 0x01, 0x1f, 0x1f, 0x00, 0x0f, 0x1f, 0x1a, 0x12, 0x1a, 0x1b, 0x0b,
0x00, 0x1f, 0x1f, 0x00, 0x1f, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
oled_write_raw_P(hell_logo, sizeof(hell_logo)); oled_write_raw_P(hell_logo, sizeof(hell_logo));
} }
/* 32 * 14 os logos */ /* 32 * 14 os logos */
static const char PROGMEM windows_logo[] = { static const char PROGMEM windows_logo[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xbc, 0xbc, 0xbe, 0xbe, 0x00, 0xbe, 0xbe, 0xbf, 0xbf, 0xbf, 0xbf, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x0f, 0x0f, 0x00, 0x0f, 0x0f, 0x1f, 0x1f, 0x1f, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xbc, 0xbc, 0xbe, 0xbe, 0x00,
0xbe, 0xbe, 0xbf, 0xbf, 0xbf, 0xbf, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x0f, 0x0f, 0x00,
0x0f, 0x0f, 0x1f, 0x1f, 0x1f, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
static const char PROGMEM mac_logo[] = { static const char PROGMEM mac_logo[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xf0, 0xf8, 0xf8, 0xf8, 0xf0, 0xf6, 0xfb, 0xfb, 0x38, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x07, 0x0f, 0x1f, 0x1f, 0x0f, 0x0f, 0x1f, 0x1f, 0x0f, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xf0, 0xf8, 0xf8, 0xf8,
0xf0, 0xf6, 0xfb, 0xfb, 0x38, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x07, 0x0f, 0x1f, 0x1f,
0x0f, 0x0f, 0x1f, 0x1f, 0x0f, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
/* Smart Backspace Delete */ /* Smart Backspace Delete */
@ -197,12 +179,12 @@ static uint16_t held_shift = 0;
/* KEYBOARD PET START */ /* KEYBOARD PET START */
/* settings */ /* settings */
#define MIN_WALK_SPEED 10 # define MIN_WALK_SPEED 10
#define MIN_RUN_SPEED 40 # define MIN_RUN_SPEED 40
/* advanced settings */ /* advanced settings */
#define ANIM_FRAME_DURATION 200 // how long each frame lasts in ms # define ANIM_FRAME_DURATION 200 // how long each frame lasts in ms
#define ANIM_SIZE 96 // number of bytes in array. If you change sprites, minimize for adequate firmware size. max is 1024 # define ANIM_SIZE 96 // number of bytes in array. If you change sprites, minimize for adequate firmware size. max is 1024
/* timers */ /* timers */
uint32_t anim_timer = 0; uint32_t anim_timer = 0;
@ -221,158 +203,92 @@ bool showedJump = true;
/* logic */ /* logic */
static void render_luna(int LUNA_X, int LUNA_Y) { static void render_luna(int LUNA_X, int LUNA_Y) {
/* Sit */ /* Sit */
static const char PROGMEM sit[2][ANIM_SIZE] = { static const char PROGMEM sit[2][ANIM_SIZE] = {/* 'sit1', 32x22px */
/* 'sit1', 32x22px */
{ {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x1c, 0x02, 0x05, 0x02, 0x24, 0x04, 0x04, 0x02, 0xa9, 0x1e, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x10, 0x08, 0x68, 0x10, 0x08, 0x04, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x06, 0x82, 0x7c, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x04, 0x0c, 0x10, 0x10, 0x20, 0x20, 0x20, 0x28, 0x3e, 0x1c, 0x20, 0x20, 0x3e, 0x0f, 0x11, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x02, 0x05, 0x02, 0x24, 0x04, 0x04, 0x02, 0xa9, 0x1e, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x10, 0x08, 0x68, 0x10, 0x08, 0x04, 0x03, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x06, 0x82, 0x7c, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x04, 0x0c, 0x10, 0x10, 0x20, 0x20, 0x20, 0x28,
0x3e, 0x1c, 0x20, 0x20, 0x3e, 0x0f, 0x11, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
}, },
/* 'sit2', 32x22px */ /* 'sit2', 32x22px */
{ {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x1c, 0x02, 0x05, 0x02, 0x24, 0x04, 0x04, 0x02, 0xa9, 0x1e, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x90, 0x08, 0x18, 0x60, 0x10, 0x08, 0x04, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x0e, 0x82, 0x7c, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x04, 0x0c, 0x10, 0x10, 0x20, 0x20, 0x20, 0x28, 0x3e, 0x1c, 0x20, 0x20, 0x3e, 0x0f, 0x11, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}};
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x1c,
0x02, 0x05, 0x02, 0x24, 0x04, 0x04, 0x02, 0xa9, 0x1e, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x90, 0x08, 0x18, 0x60, 0x10, 0x08, 0x04, 0x03, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x0e, 0x82, 0x7c, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x04, 0x0c, 0x10, 0x10, 0x20, 0x20, 0x20, 0x28,
0x3e, 0x1c, 0x20, 0x20, 0x3e, 0x0f, 0x11, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
}
};
/* Walk */ /* Walk */
static const char PROGMEM walk[2][ANIM_SIZE] = { static const char PROGMEM walk[2][ANIM_SIZE] = {/* 'walk1', 32x22px */
/* 'walk1', 32x22px */
{ {
0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x40, 0x20, 0x10, 0x90, 0x90, 0x90, 0xa0, 0xc0, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x40, 0x20, 0x10, 0x90, 0x90, 0x90, 0xa0, 0xc0, 0x80, 0x80, 0x80, 0x70, 0x08, 0x14, 0x08, 0x90, 0x10, 0x10, 0x08, 0xa4, 0x78, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x08, 0xfc, 0x01, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x18, 0xea, 0x10, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x1c, 0x20, 0x20, 0x3c, 0x0f, 0x11, 0x1f, 0x03, 0x06, 0x18, 0x20, 0x20, 0x3c, 0x0c, 0x12, 0x1e, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x80, 0x70, 0x08, 0x14, 0x08, 0x90, 0x10, 0x10, 0x08, 0xa4, 0x78, 0x80, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x08, 0xfc, 0x01, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x18, 0xea, 0x10, 0x0f, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x1c, 0x20, 0x20, 0x3c, 0x0f, 0x11, 0x1f, 0x03,
0x06, 0x18, 0x20, 0x20, 0x3c, 0x0c, 0x12, 0x1e, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
}, },
/* 'walk2', 32x22px */ /* 'walk2', 32x22px */
{ {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x40, 0x20, 0x20, 0x20, 0x40, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x40, 0x20, 0x20, 0x20, 0x40, 0x80, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x10, 0x28, 0x10, 0x20, 0x20, 0x20, 0x10, 0x48, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x20, 0xf8, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x03, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x10, 0x30, 0xd5, 0x20, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x20, 0x30, 0x0c, 0x02, 0x05, 0x09, 0x12, 0x1e, 0x02, 0x1c, 0x14, 0x08, 0x10, 0x20, 0x2c, 0x32, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0xe0, 0x10, 0x28, 0x10, 0x20, 0x20, 0x20, 0x10, 0x48, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, }};
0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x20, 0xf8, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x03, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x10, 0x30, 0xd5, 0x20, 0x1f, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x20, 0x30, 0x0c, 0x02, 0x05, 0x09, 0x12, 0x1e,
0x02, 0x1c, 0x14, 0x08, 0x10, 0x20, 0x2c, 0x32, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
}
};
/* Run */ /* Run */
static const char PROGMEM run[2][ANIM_SIZE] = { static const char PROGMEM run[2][ANIM_SIZE] = {/* 'run1', 32x22px */
/* 'run1', 32x22px */
{ {
0x00, 0x00, 0x00, 0x00, 0xe0, 0x10, 0x08, 0x08, 0xc8, 0xb0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x10, 0x08, 0x08, 0xc8, 0xb0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x40, 0x40, 0x3c, 0x14, 0x04, 0x08, 0x90, 0x18, 0x04, 0x08, 0xb0, 0x40, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0xc4, 0xa4, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xc8, 0x58, 0x28, 0x2a, 0x10, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x09, 0x04, 0x04, 0x04, 0x04, 0x02, 0x03, 0x02, 0x01, 0x01, 0x02, 0x02, 0x04, 0x08, 0x10, 0x26, 0x2b, 0x32, 0x04, 0x05, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00,
0x80, 0x40, 0x40, 0x3c, 0x14, 0x04, 0x08, 0x90, 0x18, 0x04, 0x08, 0xb0, 0x40, 0x80, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0xc4, 0xa4, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xc8, 0x58, 0x28, 0x2a, 0x10, 0x0f, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x09, 0x04, 0x04, 0x04, 0x04, 0x02, 0x03, 0x02, 0x01, 0x01,
0x02, 0x02, 0x04, 0x08, 0x10, 0x26, 0x2b, 0x32, 0x04, 0x05, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00,
}, },
/* 'run2', 32x22px */ /* 'run2', 32x22px */
{ {
0x00, 0x00, 0x00, 0xe0, 0x10, 0x10, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0xe0, 0x10, 0x10, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x80, 0x78, 0x28, 0x08, 0x10, 0x20, 0x30, 0x08, 0x10, 0x20, 0x40, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x04, 0x08, 0x10, 0x11, 0xf9, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x10, 0xb0, 0x50, 0x55, 0x20, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x0c, 0x10, 0x20, 0x28, 0x37, 0x02, 0x1e, 0x20, 0x20, 0x18, 0x0c, 0x14, 0x1e, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x80, 0x80, 0x78, 0x28, 0x08, 0x10, 0x20, 0x30, 0x08, 0x10, 0x20, 0x40, 0x80, 0x00, 0x00, 0x00, }};
0x00, 0x00, 0x00, 0x03, 0x04, 0x08, 0x10, 0x11, 0xf9, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x10, 0xb0, 0x50, 0x55, 0x20, 0x1f, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x0c, 0x10, 0x20, 0x28, 0x37,
0x02, 0x1e, 0x20, 0x20, 0x18, 0x0c, 0x14, 0x1e, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
}
};
/* Bark */ /* Bark */
static const char PROGMEM bark[2][ANIM_SIZE] = { static const char PROGMEM bark[2][ANIM_SIZE] = {/* 'bark1', 32x22px */
/* 'bark1', 32x22px */
{ {
0x00, 0xc0, 0x20, 0x10, 0xd0, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x40, 0x00, 0xc0, 0x20, 0x10, 0xd0, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x40, 0x3c, 0x14, 0x04, 0x08, 0x90, 0x18, 0x04, 0x08, 0xb0, 0x40, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x04, 0x08, 0x10, 0x11, 0xf9, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xc8, 0x48, 0x28, 0x2a, 0x10, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x0c, 0x10, 0x20, 0x28, 0x37, 0x02, 0x02, 0x04, 0x08, 0x10, 0x26, 0x2b, 0x32, 0x04, 0x05, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x3c, 0x14, 0x04, 0x08, 0x90, 0x18, 0x04, 0x08, 0xb0, 0x40, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x03, 0x04, 0x08, 0x10, 0x11, 0xf9, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x80, 0xc8, 0x48, 0x28, 0x2a, 0x10, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x0c, 0x10, 0x20, 0x28, 0x37, 0x02, 0x02,
0x04, 0x08, 0x10, 0x26, 0x2b, 0x32, 0x04, 0x05, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
}, },
/* 'bark2', 32x22px */ /* 'bark2', 32x22px */
{ {
0x00, 0xe0, 0x10, 0x10, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x40, 0x00, 0xe0, 0x10, 0x10, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x40, 0x40, 0x2c, 0x14, 0x04, 0x08, 0x90, 0x18, 0x04, 0x08, 0xb0, 0x40, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x04, 0x08, 0x10, 0x11, 0xf9, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xc0, 0x48, 0x28, 0x2a, 0x10, 0x0f, 0x20, 0x4a, 0x09, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x0c, 0x10, 0x20, 0x28, 0x37, 0x02, 0x02, 0x04, 0x08, 0x10, 0x26, 0x2b, 0x32, 0x04, 0x05, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x40, 0x2c, 0x14, 0x04, 0x08, 0x90, 0x18, 0x04, 0x08, 0xb0, 0x40, 0x80, 0x00, 0x00, 0x00, 0x00, }};
0x00, 0x03, 0x04, 0x08, 0x10, 0x11, 0xf9, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xc0, 0x48, 0x28, 0x2a, 0x10, 0x0f, 0x20, 0x4a, 0x09, 0x10,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x0c, 0x10, 0x20, 0x28, 0x37, 0x02, 0x02,
0x04, 0x08, 0x10, 0x26, 0x2b, 0x32, 0x04, 0x05, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
}
};
/* Sneak */ /* Sneak */
static const char PROGMEM sneak[2][ANIM_SIZE] = { static const char PROGMEM sneak[2][ANIM_SIZE] = {/* 'sneak1', 32x22px */
/* 'sneak1', 32x22px */
{ {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x40, 0x40, 0x40, 0x40, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x40, 0x40, 0x40, 0x40, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x40, 0x40, 0x80, 0x00, 0x80, 0x40, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1e, 0x21, 0xf0, 0x04, 0x02, 0x02, 0x02, 0x02, 0x03, 0x02, 0x02, 0x04, 0x04, 0x04, 0x03, 0x01, 0x00, 0x00, 0x09, 0x01, 0x80, 0x80, 0xab, 0x04, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x1c, 0x20, 0x20, 0x3c, 0x0f, 0x11, 0x1f, 0x02, 0x06, 0x18, 0x20, 0x20, 0x38, 0x08, 0x10, 0x18, 0x04, 0x04, 0x02, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0xc0, 0x40, 0x40, 0x80, 0x00, 0x80, 0x40, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x1e, 0x21, 0xf0, 0x04, 0x02, 0x02, 0x02, 0x02, 0x03, 0x02, 0x02, 0x04,
0x04, 0x04, 0x03, 0x01, 0x00, 0x00, 0x09, 0x01, 0x80, 0x80, 0xab, 0x04, 0xf8, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x1c, 0x20, 0x20, 0x3c, 0x0f, 0x11, 0x1f, 0x02, 0x06,
0x18, 0x20, 0x20, 0x38, 0x08, 0x10, 0x18, 0x04, 0x04, 0x02, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00,
}, },
/* 'sneak2', 32x22px */ /* 'sneak2', 32x22px */
{ {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x40, 0x40, 0x40, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x40, 0x40, 0x40, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xa0, 0x20, 0x40, 0x80, 0xc0, 0x20, 0x40, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x41, 0xf0, 0x04, 0x02, 0x02, 0x02, 0x03, 0x02, 0x02, 0x02, 0x04, 0x04, 0x02, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x40, 0x40, 0x55, 0x82, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x20, 0x30, 0x0c, 0x02, 0x05, 0x09, 0x12, 0x1e, 0x04, 0x18, 0x10, 0x08, 0x10, 0x20, 0x28, 0x34, 0x06, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0xe0, 0xa0, 0x20, 0x40, 0x80, 0xc0, 0x20, 0x40, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, }};
0x00, 0x00, 0x00, 0x00, 0x3e, 0x41, 0xf0, 0x04, 0x02, 0x02, 0x02, 0x03, 0x02, 0x02, 0x02, 0x04,
0x04, 0x02, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x40, 0x40, 0x55, 0x82, 0x7c, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x20, 0x30, 0x0c, 0x02, 0x05, 0x09, 0x12, 0x1e, 0x04,
0x18, 0x10, 0x08, 0x10, 0x20, 0x28, 0x34, 0x06, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
}
};
/* animation */ /* animation */
void animate_luna(void) { void animate_luna(void) {
/* jump */ /* jump */
if (isJumping || !showedJump) { if (isJumping || !showedJump) {
/* clear */ /* clear */
oled_set_cursor(LUNA_X,LUNA_Y +2); oled_set_cursor(LUNA_X, LUNA_Y + 2);
oled_write(" ", false); oled_write(" ", false);
oled_set_cursor(LUNA_X,LUNA_Y -1); oled_set_cursor(LUNA_X, LUNA_Y - 1);
showedJump = true; showedJump = true;
} else { } else {
/* clear */ /* clear */
oled_set_cursor(LUNA_X,LUNA_Y -1); oled_set_cursor(LUNA_X, LUNA_Y - 1);
oled_write(" ", false); oled_write(" ", false);
oled_set_cursor(LUNA_X,LUNA_Y); oled_set_cursor(LUNA_X, LUNA_Y);
} }
/* switch frame */ /* switch frame */
current_frame = (current_frame + 1) % 2; current_frame = (current_frame + 1) % 2;
/* current status */ /* current status */
if(led_usb_state.caps_lock) { if (led_usb_state.caps_lock) {
oled_write_raw_P(bark[abs(1 - current_frame)], ANIM_SIZE); oled_write_raw_P(bark[abs(1 - current_frame)], ANIM_SIZE);
} else if(isSneaking) { } else if (isSneaking) {
oled_write_raw_P(sneak[abs(1 - current_frame)], ANIM_SIZE); oled_write_raw_P(sneak[abs(1 - current_frame)], ANIM_SIZE);
} else if(current_wpm <= MIN_WALK_SPEED) { } else if (current_wpm <= MIN_WALK_SPEED) {
oled_write_raw_P(sit[abs(1 - current_frame)], ANIM_SIZE); oled_write_raw_P(sit[abs(1 - current_frame)], ANIM_SIZE);
} else if(current_wpm <= MIN_RUN_SPEED) { } else if (current_wpm <= MIN_RUN_SPEED) {
oled_write_raw_P(walk[abs(1 - current_frame)], ANIM_SIZE); oled_write_raw_P(walk[abs(1 - current_frame)], ANIM_SIZE);
} else { } else {
@ -381,7 +297,7 @@ static void render_luna(int LUNA_X, int LUNA_Y) {
} }
/* animation timer */ /* animation timer */
if(timer_elapsed32(anim_timer) > ANIM_FRAME_DURATION) { if (timer_elapsed32(anim_timer) > ANIM_FRAME_DURATION) {
anim_timer = timer_read32(); anim_timer = timer_read32();
animate_luna(); animate_luna();
} }
@ -390,10 +306,9 @@ static void render_luna(int LUNA_X, int LUNA_Y) {
if (current_wpm > 0) { if (current_wpm > 0) {
oled_on(); oled_on();
anim_sleep = timer_read32(); anim_sleep = timer_read32();
} else if(timer_elapsed32(anim_sleep) > OLED_TIMEOUT) { } else if (timer_elapsed32(anim_sleep) > OLED_TIMEOUT) {
oled_off(); oled_off();
} }
} }
/* KEYBOARD PET END */ /* KEYBOARD PET END */
@ -404,27 +319,27 @@ static void print_logo_narrow(void) {
/* wpm counter */ /* wpm counter */
uint8_t n = get_current_wpm(); uint8_t n = get_current_wpm();
char wpm_str[4]; char wpm_str[4];
oled_set_cursor(0,14); oled_set_cursor(0, 14);
wpm_str[3] = '\0'; wpm_str[3] = '\0';
wpm_str[2] = '0' + n % 10; wpm_str[2] = '0' + n % 10;
wpm_str[1] = '0' + ( n /= 10) % 10; wpm_str[1] = '0' + (n /= 10) % 10;
wpm_str[0] = '0' + n / 10; wpm_str[0] = '0' + n / 10;
oled_write(wpm_str, false); oled_write(wpm_str, false);
oled_set_cursor(0,15); oled_set_cursor(0, 15);
oled_write(" wpm", false); oled_write(" wpm", false);
} }
static void print_status_narrow(void) { static void print_status_narrow(void) {
/* Print current mode */ /* Print current mode */
oled_set_cursor(0,0); oled_set_cursor(0, 0);
if (keymap_config.swap_lctl_lgui) { if (keymap_config.swap_lctl_lgui) {
oled_write_raw_P(mac_logo, sizeof(mac_logo)); oled_write_raw_P(mac_logo, sizeof(mac_logo));
} else { } else {
oled_write_raw_P(windows_logo, sizeof(windows_logo)); oled_write_raw_P(windows_logo, sizeof(windows_logo));
} }
oled_set_cursor(0,3); oled_set_cursor(0, 3);
switch (get_highest_layer(default_layer_state)) { switch (get_highest_layer(default_layer_state)) {
case _QWERTY: case _QWERTY:
@ -437,12 +352,12 @@ static void print_status_narrow(void) {
oled_write("UNDEF", false); oled_write("UNDEF", false);
} }
oled_set_cursor(0,5); oled_set_cursor(0, 5);
/* Print current layer */ /* Print current layer */
oled_write("LAYER", false); oled_write("LAYER", false);
oled_set_cursor(0,6); oled_set_cursor(0, 6);
switch (get_highest_layer(layer_state)) { switch (get_highest_layer(layer_state)) {
case _QWERTY: case _QWERTY:
@ -465,22 +380,19 @@ static void print_status_narrow(void) {
} }
/* caps lock */ /* caps lock */
oled_set_cursor(0,8); oled_set_cursor(0, 8);
oled_write("CPSLK", led_usb_state.caps_lock); oled_write("CPSLK", led_usb_state.caps_lock);
/* KEYBOARD PET RENDER START */ /* KEYBOARD PET RENDER START */
render_luna(0,13); render_luna(0, 13);
/* KEYBOARD PET RENDER END */ /* KEYBOARD PET RENDER END */
} }
oled_rotation_t oled_init_user(oled_rotation_t rotation) { oled_rotation_t oled_init_user(oled_rotation_t rotation) { return OLED_ROTATION_270; }
return OLED_ROTATION_270;
}
void oled_task_user(void) { void oled_task_user(void) {
/* KEYBOARD PET VARIABLES START */ /* KEYBOARD PET VARIABLES START */
current_wpm = get_current_wpm(); current_wpm = get_current_wpm();
@ -687,7 +599,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
if (record->event.pressed) { if (record->event.pressed) {
if (get_highest_layer(default_layer_state) == _QWERTY) { if (get_highest_layer(default_layer_state) == _QWERTY) {
set_single_persistent_default_layer(_GAMING); set_single_persistent_default_layer(_GAMING);
} else if(get_highest_layer(default_layer_state) == _GAMING) { } else if (get_highest_layer(default_layer_state) == _GAMING) {
set_single_persistent_default_layer(_QWERTY); set_single_persistent_default_layer(_QWERTY);
} }
} }
@ -727,16 +639,16 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#ifdef ENCODER_ENABLE #ifdef ENCODER_ENABLE
void encoder_update_user(uint8_t index, bool clockwise) { bool encoder_update_user(uint8_t index, bool clockwise) {
if (index == 0) { if (index == 0) {
if (clockwise) { if (clockwise) {
if(shift_held) { if (shift_held) {
tap_code(KC_MNXT); tap_code(KC_MNXT);
} else { } else {
tap_code(KC_RIGHT); tap_code(KC_RIGHT);
} }
} else { } else {
if(shift_held) { if (shift_held) {
tap_code(KC_MPRV); tap_code(KC_MPRV);
} else { } else {
tap_code(KC_LEFT); tap_code(KC_LEFT);
@ -744,19 +656,20 @@ void encoder_update_user(uint8_t index, bool clockwise) {
} }
} else if (index == 1) { } else if (index == 1) {
if (clockwise) { if (clockwise) {
if(shift_held) { if (shift_held) {
tap_code(KC_VOLU); tap_code(KC_VOLU);
} else { } else {
tap_code(KC_DOWN); tap_code(KC_DOWN);
} }
} else { } else {
if(shift_held) { if (shift_held) {
tap_code(KC_VOLD); tap_code(KC_VOLD);
} else { } else {
tap_code(KC_UP); tap_code(KC_UP);
} }
} }
} }
return true;
} }
#endif #endif

9
keyboards/work_louder/loop/keymaps/default/keymap.c
View file

@ -15,10 +15,8 @@
*/ */
#include QMK_KEYBOARD_H #include QMK_KEYBOARD_H
// clang-format off
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
/* Base */
[0] = LAYOUT( [0] = LAYOUT(
KC_MUTE, KC_MPLY, R_M_TOG, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, MO(1) KC_MUTE, KC_MPLY, R_M_TOG, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, MO(1)
), ),
@ -29,9 +27,9 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
RESET, _______, R_M_TOG, R_M_MOD, R_M_HUI, R_M_HUD, R_M_SAI, R_M_SAD, R_M_VAI, R_M_VAD, _______, _______ RESET, _______, R_M_TOG, R_M_MOD, R_M_HUI, R_M_HUD, R_M_SAI, R_M_SAD, R_M_VAI, R_M_VAD, _______, _______
) )
}; };
// clang-format on
// bool encoder_update_user(uint8_t index, bool clockwise) {
// void encoder_update_user(uint8_t index, bool clockwise) {
// if (index == 0) { // if (index == 0) {
// if (clockwise) { // if (clockwise) {
// tap_code(KC_VOLD); // tap_code(KC_VOLD);
@ -51,4 +49,5 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
// rgb_matrix_step(); // rgb_matrix_step();
// } // }
// } // }
// return false;
// } // }

15
keyboards/work_louder/nano/keymaps/default/keymap.c
View file

@ -15,23 +15,16 @@
*/ */
#include QMK_KEYBOARD_H #include QMK_KEYBOARD_H
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
/* Base */ /* Base */
[0] = LAYOUT( [0] = LAYOUT(KC_PSCR, KC_LSFT, MO(1)),
KC_PSCR, KC_LSFT, MO(1) [1] = LAYOUT(RESET, KC_LCTL, _______)};
),
[1] = LAYOUT(
RESET, KC_LCTL, _______
)
};
// bool encoder_update_user(uint8_t index, bool clockwise) {
// void encoder_update_user(uint8_t index, bool clockwise) {
// if (clockwise) { // if (clockwise) {
// tap_code(KC_PGDN); // tap_code(KC_PGDN);
// } else { // } else {
// tap_code(KC_PGUP); // tap_code(KC_PGUP);
// } // }
// return false;
// } // }

3
layouts/community/ortho_4x12/drashna/keymap.c
View file

@ -368,7 +368,7 @@ bool encoder_update_user(uint8_t index, bool clockwise) {
#endif // ENCODER_ENABLE #endif // ENCODER_ENABLE
#ifdef KEYBOARD_planck_rev6 #ifdef KEYBOARD_planck_rev6
void dip_update(uint8_t index, bool active) { bool dip_switch_update_user(uint8_t index, bool active) {
switch (index) { switch (index) {
case 0: case 0:
if (active) { if (active) {
@ -391,6 +391,7 @@ void dip_update(uint8_t index, bool active) {
userspace_config.nuke_switch = active; userspace_config.nuke_switch = active;
break; break;
} }
return true;
} }
#endif // KEYBOARD_planck_rev6 #endif // KEYBOARD_planck_rev6

3
layouts/community/ortho_4x12/juno/keymap.c
View file

@ -395,7 +395,7 @@ bool encoder_update_user(uint8_t index, bool clockwise) {
return true; return true;
} }
void dip_update(uint8_t index, bool active) { bool dip_switch_update_user(uint8_t index, bool active) {
switch (index) { switch (index) {
case 0: case 0:
if (active) { if (active) {
@ -420,6 +420,7 @@ void dip_update(uint8_t index, bool active) {
#endif #endif
} }
} }
return true;
} }
void matrix_scan_user(void) { void matrix_scan_user(void) {

3
layouts/community/ortho_4x12/junonum/keymap.c
View file

@ -293,7 +293,7 @@ bool encoder_update_user(uint8_t index, bool clockwise) {
return true; return true;
} }
void dip_update(uint8_t index, bool active) { bool dip_switch_update_user(uint8_t index, bool active) {
switch (index) { switch (index) {
case 0: case 0:
if (active) { if (active) {
@ -318,6 +318,7 @@ void dip_update(uint8_t index, bool active) {
#endif #endif
} }
} }
return true;
} }
void matrix_scan_user(void) { void matrix_scan_user(void) {