aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorDrashna Jaelre <drashna@live.com>2020-03-31 16:26:43 -0700
committerGitHub <noreply@github.com>2020-03-31 16:26:43 -0700
commitc67e30459390982f4f1b47f46c62322f1fe9ba87 (patch)
treed3504649cb692e58823bc7589d1a032256d9b0c1
parent8c80475fcc568e04f637ae973086b65a31b5254d (diff)
downloadqmk_firmware-c67e30459390982f4f1b47f46c62322f1fe9ba87.tar.gz
qmk_firmware-c67e30459390982f4f1b47f46c62322f1fe9ba87.zip
[Keymap] Drashna's Cleanup and RGB Divide (#8506)
* Enable External EEPROM on Planck Rev6 * Update KC_MAKE macro to use qmk cli util * Disable additional gradients for rgb matrix * Update analog code for newer methods * Update ergodox layout * Disable Grave Escape * Cleanup OLED code a bit * Remove old unicode code * Seperate RGB Matrix code from RGB Light code in userspace * Massive overhaul an generalization of personal OLED code Now lets hope I NEVER get a keyboard using a 128x32 in a normal orientation. * Super tiny cleanup * Enable Diablo layer on kyria * clang format pass * Additional OLED cleanup
Diffstat
-rw-r--r--keyboards/40percentclub/nano/keymaps/drashna/keymap.c20
-rw-r--r--keyboards/40percentclub/nano/keymaps/drashna/rules.mk2
-rw-r--r--keyboards/crkbd/keymaps/drashna/keymap.c177
-rw-r--r--keyboards/kyria/keymaps/drashna/config.h2
-rw-r--r--keyboards/kyria/keymaps/drashna/keymap.c208
-rw-r--r--keyboards/kyria/keymaps/drashna/rules.mk2
-rw-r--r--layouts/community/ergodox/drashna/config.h2
-rw-r--r--layouts/community/ergodox/drashna/rules.mk7
-rw-r--r--layouts/community/ortho_4x12/drashna/config.h2
-rw-r--r--layouts/community/ortho_4x12/drashna/rules.mk2
-rw-r--r--users/drashna/config.h3
-rw-r--r--users/drashna/drashna.c35
-rw-r--r--users/drashna/drashna.h9
-rw-r--r--users/drashna/oled_stuff.c278
-rw-r--r--users/drashna/oled_stuff.h91
-rw-r--r--users/drashna/process_records.c359
-rw-r--r--users/drashna/process_records.h18
-rw-r--r--users/drashna/rgb_matrix_stuff.c86
-rw-r--r--users/drashna/rgb_matrix_stuff.h9
-rw-r--r--users/drashna/rgb_stuff.c404
-rw-r--r--users/drashna/rgb_stuff.h26
-rw-r--r--users/drashna/rules.mk13
22 files changed, 888 insertions, 867 deletions
diff --git a/keyboards/40percentclub/nano/keymaps/drashna/keymap.c b/keyboards/40percentclub/nano/keymaps/drashna/keymap.c
index 668178967..998e55d5b 100644
--- a/keyboards/40percentclub/nano/keymaps/drashna/keymap.c
+++ b/keyboards/40percentclub/nano/keymaps/drashna/keymap.c
@@ -1,5 +1,5 @@
1#include "drashna.h" 1#include "drashna.h"
2#include "analog.c" 2#include "analog.h"
3#include "pointing_device.h" 3#include "pointing_device.h"
4#include "pincontrol.h" 4#include "pincontrol.h"
5 5
@@ -17,8 +17,8 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
17 17
18// Joystick 18// Joystick
19// Set Pins 19// Set Pins
20uint8_t xPin = 8; // VRx / /B4 20// uint8_t xPin = 8; // VRx / /B4
21uint8_t yPin = 7; // VRy // B5 21// uint8_t yPin = 7; // VRy // B5
22uint8_t swPin = E6; // SW 22uint8_t swPin = E6; // SW
23 23
24// Set Parameters 24// Set Parameters
@@ -43,7 +43,7 @@ int16_t axisCoordinate(uint8_t pin, uint16_t origin) {
43 int16_t distanceFromOrigin; 43 int16_t distanceFromOrigin;
44 int16_t range; 44 int16_t range;
45 45
46 int16_t position = analogRead(pin); 46 int16_t position = analogReadPin(pin);
47 47
48 if (origin == position) { 48 if (origin == position) {
49 return 0; 49 return 0;
@@ -88,11 +88,11 @@ void pointing_device_task(void) {
88 // todo read as one vector 88 // todo read as one vector
89 if (timer_elapsed(lastCursor) > cursorTimeout) { 89 if (timer_elapsed(lastCursor) > cursorTimeout) {
90 lastCursor = timer_read(); 90 lastCursor = timer_read();
91 report.x = axisToMouseComponent(xPin, xOrigin, maxCursorSpeed, xPolarity); 91 report.x = axisToMouseComponent(B4, xOrigin, maxCursorSpeed, xPolarity);
92 report.y = axisToMouseComponent(yPin, yOrigin, maxCursorSpeed, yPolarity); 92 report.y = axisToMouseComponent(B5, yOrigin, maxCursorSpeed, yPolarity);
93 } 93 }
94 // 94 //
95 if (!readPin(swPin)) { 95 if (!readPin(E6)) {
96 report.buttons |= MOUSE_BTN1; 96 report.buttons |= MOUSE_BTN1;
97 } else { 97 } else {
98 report.buttons &= ~MOUSE_BTN1; 98 report.buttons &= ~MOUSE_BTN1;
@@ -104,8 +104,8 @@ void pointing_device_task(void) {
104 104
105void matrix_init_keymap(void) { 105void matrix_init_keymap(void) {
106 // init pin? Is needed? 106 // init pin? Is needed?
107 setPinInputHigh(swPin); 107 setPinInputHigh(E6);
108 // Account for drift 108 // Account for drift
109 xOrigin = analogRead(xPin); 109 xOrigin = analogReadPin(B4);
110 yOrigin = analogRead(yPin); 110 yOrigin = analogReadPin(B5);
111} 111}
diff --git a/keyboards/40percentclub/nano/keymaps/drashna/rules.mk b/keyboards/40percentclub/nano/keymaps/drashna/rules.mk
index 06110a0a2..2b72a112b 100644
--- a/keyboards/40percentclub/nano/keymaps/drashna/rules.mk
+++ b/keyboards/40percentclub/nano/keymaps/drashna/rules.mk
@@ -3,3 +3,5 @@ RGBLIGHT_ENABLE = no
3CONSOLE_ENABLE = no 3CONSOLE_ENABLE = no
4 4
5BOOTLOADER = qmk-dfu 5BOOTLOADER = qmk-dfu
6
7SRC += analog.c
diff --git a/keyboards/crkbd/keymaps/drashna/keymap.c b/keyboards/crkbd/keymaps/drashna/keymap.c
index 9a1beeb74..55d51eb08 100644
--- a/keyboards/crkbd/keymaps/drashna/keymap.c
+++ b/keyboards/crkbd/keymaps/drashna/keymap.c
@@ -6,34 +6,6 @@ extern uint8_t is_master;
6// Following line allows macro to read current RGB settings 6// Following line allows macro to read current RGB settings
7extern rgblight_config_t rgblight_config; 7extern rgblight_config_t rgblight_config;
8#endif 8#endif
9#ifdef OLED_DRIVER_ENABLE
10# define KEYLOGGER_LENGTH 5
11static uint32_t oled_timer = 0;
12static char keylog_str[KEYLOGGER_LENGTH + 1] = {"\n"};
13static uint16_t log_timer = 0;
14// clang-format off
15static const char PROGMEM code_to_name[0xFF] = {
16// 0 1 2 3 4 5 6 7 8 9 A B c D E F
17 ' ', ' ', ' ', ' ', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', // 0x
18 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '1', '2', // 1x
19 '3', '4', '5', '6', '7', '8', '9', '0', 20, 19, 27, 26, 22, '-', '=', '[', // 2x
20 ']','\\', '#', ';','\'', '`', ',', '.', '/', 128, ' ', ' ', ' ', ' ', ' ', ' ', // 3x
21 ' ', ' ', ' ', ' ', ' ', ' ', 'P', 'S', ' ', ' ', ' ', ' ', 16, ' ', ' ', ' ', // 4x
22 ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', // 5x
23 ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', // 6x
24 ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', // 7x
25 ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', // 8x
26 ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', // 9x
27 ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', // Ax
28 ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', // Bx
29 ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', // Cx
30 ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', // Dx
31 'C', 'S', 'A', 'C', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', // Ex
32 ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ' // Fx
33};
34
35void add_keylog(uint16_t keycode);
36#endif
37 9
38enum crkbd_keycodes { RGBRST = NEW_SAFE_RANGE }; 10enum crkbd_keycodes { RGBRST = NEW_SAFE_RANGE };
39 11
@@ -139,10 +111,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
139 111
140bool process_record_keymap(uint16_t keycode, keyrecord_t *record) { 112bool process_record_keymap(uint16_t keycode, keyrecord_t *record) {
141 if (record->event.pressed) { 113 if (record->event.pressed) {
142#ifdef OLED_DRIVER_ENABLE
143 oled_timer = timer_read32();
144 add_keylog(keycode);
145#endif
146#ifndef SPLIT_KEYBOARD 114#ifndef SPLIT_KEYBOARD
147 if (keycode == RESET && !is_master) { 115 if (keycode == RESET && !is_master) {
148 return false; 116 return false;
@@ -154,151 +122,6 @@ bool process_record_keymap(uint16_t keycode, keyrecord_t *record) {
154 122
155#ifdef OLED_DRIVER_ENABLE 123#ifdef OLED_DRIVER_ENABLE
156oled_rotation_t oled_init_user(oled_rotation_t rotation) { return OLED_ROTATION_270; } 124oled_rotation_t oled_init_user(oled_rotation_t rotation) { return OLED_ROTATION_270; }
157
158void add_keylog(uint16_t keycode) {
159 if ((keycode >= QK_MOD_TAP && keycode <= QK_MOD_TAP_MAX) || (keycode >= QK_LAYER_TAP && keycode <= QK_LAYER_TAP_MAX) || (keycode >= QK_MODS && keycode <= QK_MODS_MAX)) {
160 keycode = keycode & 0xFF;
161 } else if (keycode > 0xFF) {
162 keycode = 0;
163 }
164
165 for (uint8_t i = (KEYLOGGER_LENGTH - 1); i > 0; --i) {
166 keylog_str[i] = keylog_str[i - 1];
167 }
168
169 if (keycode < (sizeof(code_to_name) / sizeof(char))) {
170 keylog_str[0] = pgm_read_byte(&code_to_name[keycode]);
171 }
172
173 log_timer = timer_read();
174}
175
176void update_log(void) {
177 if (timer_elapsed(log_timer) > 750) {
178 // add_keylog(0);
179 }
180}
181
182void render_keylogger_status(void) {
183 oled_write_P(PSTR("KLogr"), false);
184 oled_write(keylog_str, false);
185}
186
187void render_default_layer_state(void) {
188 oled_write_P(PSTR("Lyout"), false);
189 switch (get_highest_layer(default_layer_state)) {
190 case _QWERTY:
191 oled_write_P(PSTR(" QRTY"), false);
192 break;
193 case _COLEMAK:
194 oled_write_P(PSTR(" COLE"), false);
195 break;
196 case _DVORAK:
197 oled_write_P(PSTR(" DVRK"), false);
198 break;
199 case _WORKMAN:
200 oled_write_P(PSTR(" WKMN"), false);
201 break;
202 case _NORMAN:
203 oled_write_P(PSTR(" NORM"), false);
204 break;
205 case _MALTRON:
206 oled_write_P(PSTR(" MLTN"), false);
207 break;
208 case _EUCALYN:
209 oled_write_P(PSTR(" ECLN"), false);
210 break;
211 case _CARPLAX:
212 oled_write_P(PSTR(" CRPX"), false);
213 break;
214 }
215}
216
217void render_layer_state(void) {
218 oled_write_P(PSTR("LAYER"), false);
219 oled_write_P(PSTR("Lower"), layer_state_is(_LOWER));
220 oled_write_P(PSTR("Raise"), layer_state_is(_RAISE));
221 oled_write_P(PSTR(" Mods"), layer_state_is(_MODS));
222}
223
224void render_keylock_status(uint8_t led_usb_state) {
225 oled_write_P(PSTR("Lock:"), false);
226 oled_write_P(PSTR(" "), false);
227 oled_write_P(PSTR("N"), led_usb_state & (1 << USB_LED_NUM_LOCK));
228 oled_write_P(PSTR("C"), led_usb_state & (1 << USB_LED_CAPS_LOCK));
229 oled_write_ln_P(PSTR("S"), led_usb_state & (1 << USB_LED_SCROLL_LOCK));
230}
231
232void render_mod_status(uint8_t modifiers) {
233 oled_write_P(PSTR("Mods:"), false);
234 oled_write_P(PSTR(" "), false);
235 oled_write_P(PSTR("S"), (modifiers & MOD_MASK_SHIFT));
236 oled_write_P(PSTR("C"), (modifiers & MOD_MASK_CTRL));
237 oled_write_P(PSTR("A"), (modifiers & MOD_MASK_ALT));
238 oled_write_P(PSTR("G"), (modifiers & MOD_MASK_GUI));
239}
240
241void render_bootmagic_status(void) {
242 /* Show Ctrl-Gui Swap options */
243 static const char PROGMEM logo[][2][3] = {
244 {{0x97, 0x98, 0}, {0xb7, 0xb8, 0}},
245 {{0x95, 0x96, 0}, {0xb5, 0xb6, 0}},
246 };
247 oled_write_P(PSTR("BTMGK"), false);
248 oled_write_P(PSTR(" "), false);
249 oled_write_P(logo[0][0], !keymap_config.swap_lctl_lgui);
250 oled_write_P(logo[1][0], keymap_config.swap_lctl_lgui);
251 oled_write_P(PSTR(" "), false);
252 oled_write_P(logo[0][1], !keymap_config.swap_lctl_lgui);
253 oled_write_P(logo[1][1], keymap_config.swap_lctl_lgui);
254 oled_write_P(PSTR(" NKRO"), keymap_config.nkro);
255}
256
257void render_user_status(void) {
258 oled_write_P(PSTR("USER:"), false);
259 oled_write_P(PSTR(" Anim"), userspace_config.rgb_matrix_idle_anim);
260 oled_write_P(PSTR(" Layr"), userspace_config.rgb_layer_change);
261 oled_write_P(PSTR(" Nuke"), userspace_config.nuke_switch);
262}
263
264void render_status_main(void) {
265 /* Show Keyboard Layout */
266 render_default_layer_state();
267 render_keylock_status(host_keyboard_leds());
268 render_bootmagic_status();
269 render_user_status();
270
271 render_keylogger_status();
272}
273
274void render_status_secondary(void) {
275 /* Show Keyboard Layout */
276 render_default_layer_state();
277 render_layer_state();
278 render_mod_status(get_mods() | get_oneshot_mods());
279
280 render_keylogger_status();
281}
282
283void oled_task_user(void) {
284 if (timer_elapsed32(oled_timer) > 30000) {
285 oled_off();
286 return;
287 }
288# ifndef SPLIT_KEYBOARD
289 else {
290 oled_on();
291 }
292# endif
293
294 update_log();
295 if (is_master) {
296 render_status_main(); // Renders the current keyboard state (layer, lock, caps, scroll, etc)
297 } else {
298 render_status_secondary();
299 }
300}
301
302#endif 125#endif
303 126
304uint16_t get_tapping_term(uint16_t keycode) { 127uint16_t get_tapping_term(uint16_t keycode) {
diff --git a/keyboards/kyria/keymaps/drashna/config.h b/keyboards/kyria/keymaps/drashna/config.h
index e566b16d5..f93069ac0 100644
--- a/keyboards/kyria/keymaps/drashna/config.h
+++ b/keyboards/kyria/keymaps/drashna/config.h
@@ -37,3 +37,5 @@
37// If you are using an Elite C rev3 on the slave side, uncomment the lines below: 37// If you are using an Elite C rev3 on the slave side, uncomment the lines below:
38#define SPLIT_USB_DETECT 38#define SPLIT_USB_DETECT
39#define SPLIT_USB_TIMEOUT 1000 39#define SPLIT_USB_TIMEOUT 1000
40
41#define KEYLOGGER_LENGTH 10
diff --git a/keyboards/kyria/keymaps/drashna/keymap.c b/keyboards/kyria/keymaps/drashna/keymap.c
index 5604f1a69..5e97ca55a 100644
--- a/keyboards/kyria/keymaps/drashna/keymap.c
+++ b/keyboards/kyria/keymaps/drashna/keymap.c
@@ -2,35 +2,6 @@
2 2
3uint8_t is_master; 3uint8_t is_master;
4 4
5#ifdef OLED_DRIVER_ENABLE
6# define KEYLOGGER_LENGTH 10
7static uint32_t oled_timer = 0;
8static char keylog_str[KEYLOGGER_LENGTH + 1] = {"\n"};
9static uint16_t log_timer = 0;
10// clang-format off
11static const char PROGMEM code_to_name[0xFF] = {
12// 0 1 2 3 4 5 6 7 8 9 A B c D E F
13 ' ', ' ', ' ', ' ', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', // 0x
14 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '1', '2', // 1x
15 '3', '4', '5', '6', '7', '8', '9', '0', 20, 19, 27, 26, 22, '-', '=', '[', // 2x
16 ']','\\', '#', ';','\'', '`', ',', '.', '/', 128, ' ', ' ', ' ', ' ', ' ', ' ', // 3x
17 ' ', ' ', ' ', ' ', ' ', ' ', 'P', 'S', ' ', ' ', ' ', ' ', 16, ' ', ' ', ' ', // 4x
18 ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', // 5x
19 ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', // 6x
20 ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', // 7x
21 ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', // 8x
22 ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', // 9x
23 ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', // Ax
24 ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', // Bx
25 ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', // Cx
26 ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', // Dx
27 'C', 'S', 'A', 'C', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', // Ex
28 ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ' // Fx
29};
30
31void add_keylog(uint16_t keycode);
32#endif
33
34#ifndef UNICODE_ENABLE 5#ifndef UNICODE_ENABLE
35# define UC(x) KC_NO 6# define UC(x) KC_NO
36#endif 7#endif
@@ -52,7 +23,7 @@ void add_keylog(uint16_t keycode);
52 LAYOUT_wrapper( \ 23 LAYOUT_wrapper( \
53 KC_ESC, K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, KC_MINS, \ 24 KC_ESC, K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, KC_MINS, \
54 LALT_T(KC_TAB), K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, RALT_T(KC_QUOT), \ 25 LALT_T(KC_TAB), K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, RALT_T(KC_QUOT), \
55 OS_LSFT, CTL_T(K21), K22, K23, K24, K25, KC_NO, KC_NO, MEH(KC_MINS), KC_NO, K26, K27, K28, K29, RCTL_T(K2A), OS_RSFT, \ 26 OS_LSFT, CTL_T(K21), K22, K23, K24, K25, KC_NO, MEH(KC_MINS), TG(_DIABLO), KC_NO, K26, K27, K28, K29, RCTL_T(K2A), OS_RSFT, \
56 KC_MUTE, OS_LALT, KC_GRV, KC_SPC, BK_LWER, DL_RAIS, KC_ENT, OS_RGUI, UC(0x03A8), UC(0x2E2E) \ 27 KC_MUTE, OS_LALT, KC_GRV, KC_SPC, BK_LWER, DL_RAIS, KC_ENT, OS_RGUI, UC(0x03A8), UC(0x2E2E) \
57 ) 28 )
58/* Re-pass though to allow templates to be used */ 29/* Re-pass though to allow templates to be used */
@@ -107,12 +78,19 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
107 _____________CARPLAX_QFMLWY_L2_____________, _____________CARPLAX_QFMLWY_R2_____________, 78 _____________CARPLAX_QFMLWY_L2_____________, _____________CARPLAX_QFMLWY_R2_____________,
108 _____________CARPLAX_QFMLWY_L3_____________, _____________CARPLAX_QFMLWY_R3_____________ 79 _____________CARPLAX_QFMLWY_L3_____________, _____________CARPLAX_QFMLWY_R3_____________
109 ), 80 ),
81
110 [_MODS] = LAYOUT_wrapper( 82 [_MODS] = LAYOUT_wrapper(
111 _______, ___________________BLANK___________________, ___________________BLANK___________________, _______, 83 _______, ___________________BLANK___________________, ___________________BLANK___________________, _______,
112 _______, ___________________BLANK___________________, ___________________BLANK___________________, _______, 84 _______, ___________________BLANK___________________, ___________________BLANK___________________, _______,
113 KC_LSFT, ___________________BLANK___________________, _______, _______, _______, _______, ___________________BLANK___________________, KC_RSFT, 85 KC_LSFT, ___________________BLANK___________________, _______, _______, _______, _______, ___________________BLANK___________________, KC_RSFT,
114 _______, _______, KC_LALT, _______, _______, _______, _______, KC_RGUI, _______, _______ 86 _______, _______, KC_LALT, _______, _______, _______, _______, KC_RGUI, _______, _______
115 ), 87 ),
88 [_DIABLO] = LAYOUT_wrapper(
89 KC_ESC, KC_S, KC_I, KC_F, KC_M, KC_T, KC_F9, KC_F10, KC_F11, KC_F12, KC_NO, KC_NO,
90 KC_TAB, KC_1, KC_2, KC_3, KC_4, KC_G, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO,
91 KC_LCTL, KC_D3_1, KC_D3_2, KC_D3_3, KC_D3_4, KC_Z, KC_J, KC_L, TG(_DIABLO), KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO,
92 KC_DIABLO_CLEAR, KC_J, KC_NO, SFT_T(KC_SPACE), ALT_T(KC_Q), KC_NO, KC_NO, KC_NO, KC_NO, KC_NO
93 ),
116 [_LOWER] = LAYOUT_wrapper( 94 [_LOWER] = LAYOUT_wrapper(
117 KC_F12, _________________LOWER_L1__________________, _________________LOWER_R1__________________, KC_F11, 95 KC_F12, _________________LOWER_L1__________________, _________________LOWER_R1__________________, KC_F11,
118 _______, _________________LOWER_L2__________________, _________________LOWER_R2__________________, KC_PIPE, 96 _______, _________________LOWER_L2__________________, _________________LOWER_R2__________________, KC_PIPE,
@@ -142,10 +120,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
142 120
143bool process_record_keymap(uint16_t keycode, keyrecord_t *record) { 121bool process_record_keymap(uint16_t keycode, keyrecord_t *record) {
144 if (record->event.pressed) { 122 if (record->event.pressed) {
145#ifdef OLED_DRIVER_ENABLE
146 oled_timer = timer_read32();
147 add_keylog(keycode);
148#endif
149#ifndef SPLIT_KEYBOARD 123#ifndef SPLIT_KEYBOARD
150 if (keycode == RESET && !is_master) { 124 if (keycode == RESET && !is_master) {
151 return false; 125 return false;
@@ -154,133 +128,16 @@ bool process_record_keymap(uint16_t keycode, keyrecord_t *record) {
154 } 128 }
155 return true; 129 return true;
156} 130}
131
157void matrix_init_keymap(void) { is_master = (uint8_t)is_keyboard_master(); } 132void matrix_init_keymap(void) { is_master = (uint8_t)is_keyboard_master(); }
158 133
159#ifdef OLED_DRIVER_ENABLE 134#ifdef OLED_DRIVER_ENABLE
160oled_rotation_t oled_init_user(oled_rotation_t rotation) { return OLED_ROTATION_180; } 135oled_rotation_t oled_init_user(oled_rotation_t rotation) { return OLED_ROTATION_180; }
161 136
162void add_keylog(uint16_t keycode) {
163 if ((keycode >= QK_MOD_TAP && keycode <= QK_MOD_TAP_MAX) || (keycode >= QK_LAYER_TAP && keycode <= QK_LAYER_TAP_MAX) || (keycode >= QK_MODS && keycode <= QK_MODS_MAX)) {
164 keycode = keycode & 0xFF;
165 } else if (keycode > 0xFF) {
166 keycode = 0;
167 }
168
169 for (uint8_t i = (KEYLOGGER_LENGTH - 1); i > 0; --i) {
170 keylog_str[i] = keylog_str[i - 1];
171 }
172
173 if (keycode < (sizeof(code_to_name) / sizeof(char))) {
174 keylog_str[0] = pgm_read_byte(&code_to_name[keycode]);
175 }
176
177 log_timer = timer_read();
178}
179
180void update_log(void) {
181 if (timer_elapsed(log_timer) > 750) {
182 // add_keylog(0);
183 }
184}
185
186void render_keylogger_status(void) {
187 oled_write_P(PSTR("Keylogger: "), false);
188 oled_write(keylog_str, false);
189}
190
191void render_default_layer_state(void) {
192 oled_write_P(PSTR("Layout: "), false);
193 switch (get_highest_layer(default_layer_state)) {
194 case _QWERTY: oled_write_ln_P(PSTR("Qwerty"), false); break;
195 case _COLEMAK: oled_write_ln_P(PSTR("Colemak"), false); break;
196 case _DVORAK: oled_write_ln_P(PSTR("Dvorak"), false); break;
197 case _WORKMAN: oled_write_ln_P(PSTR("Workman"), false); break;
198 case _NORMAN: oled_write_ln_P(PSTR("Norman"), false); break;
199 case _MALTRON: oled_write_ln_P(PSTR("Maltron"), false); break;
200 case _EUCALYN: oled_write_ln_P(PSTR("Eucalyn"), false); break;
201 case _CARPLAX: oled_write_ln_P(PSTR("Carplax"), false); break;
202 }
203}
204
205void render_layer_state(void) {
206 oled_write_ln_P(PSTR("Layer:"), false);
207 oled_write_P(PSTR(" "), false);
208 oled_write_P(PSTR("Lower"), layer_state_is(_LOWER));
209 oled_write_P(PSTR(" "), false);
210 oled_write_P(PSTR("Raise"), layer_state_is(_RAISE));
211 oled_write_P(PSTR(" "), false);
212 oled_write_ln_P(PSTR("Mods"), layer_state_is(_MODS));
213}
214
215void render_keylock_status(uint8_t led_usb_state) {
216 oled_write_P(PSTR("Lock: "), false);
217 oled_write_P(PSTR("NUML"), led_usb_state & (1 << USB_LED_NUM_LOCK));
218 oled_write_P(PSTR(" "), false);
219 oled_write_P(PSTR("CAPS"), led_usb_state & (1 << USB_LED_CAPS_LOCK));
220 oled_write_P(PSTR(" "), false);
221 oled_write_ln_P(PSTR("SCLK"), led_usb_state & (1 << USB_LED_SCROLL_LOCK));
222}
223
224void render_mod_status(uint8_t modifiers) {
225 oled_write_P(PSTR("Mods: "), false);
226 oled_write_P(PSTR("Sft"), (modifiers & MOD_MASK_SHIFT));
227 oled_write_P(PSTR(" "), false);
228 oled_write_P(PSTR("Ctl"), (modifiers & MOD_MASK_CTRL));
229 oled_write_P(PSTR(" "), false);
230 oled_write_P(PSTR("Alt"), (modifiers & MOD_MASK_ALT));
231 oled_write_P(PSTR(" "), false);
232 oled_write_P(PSTR("GUI"), (modifiers & MOD_MASK_GUI));
233}
234
235void render_bootmagic_status(void) {
236 /* Show Ctrl-Gui Swap options */
237 static const char PROGMEM logo[][2][3] = {
238 {{0x97, 0x98, 0}, {0xb7, 0xb8, 0}},
239 {{0x95, 0x96, 0}, {0xb5, 0xb6, 0}},
240 };
241 oled_write_P(PSTR("Boot "), false);
242 if (keymap_config.swap_lctl_lgui) {
243 oled_write_P(logo[1][0], false);
244 } else {
245 oled_write_P(logo[0][0], false);
246 }
247 oled_write_P(PSTR(" "), false);
248 oled_write_P(PSTR("NKRO"), keymap_config.nkro);
249 oled_write_P(PSTR(" "), false);
250 oled_write_ln_P(PSTR("GUI"), !keymap_config.no_gui);
251 oled_write_P(PSTR("Magic "), false);
252 if (keymap_config.swap_lctl_lgui) {
253 oled_write_P(logo[1][1], false);
254 } else {
255 oled_write_P(logo[0][1], false);
256 }
257 oled_write_P(PSTR(" "), false);
258 oled_write_P(PSTR("GRV"), keymap_config.swap_grave_esc);
259 oled_write_P(PSTR(" "), false);
260 oled_write_ln_P(PSTR("CAPS"), keymap_config.swap_control_capslock);
261}
262
263void render_user_status(void) {
264 oled_write_P(PSTR("USER: "), false);
265 oled_write_P(PSTR("Anim"), userspace_config.rgb_matrix_idle_anim);
266 oled_write_P(PSTR(" "), false);
267 oled_write_P(PSTR("Layr"), userspace_config.rgb_layer_change);
268 oled_write_P(PSTR(" "), false);
269 oled_write_ln_P(PSTR("Nuke"), userspace_config.nuke_switch);
270}
271
272// clang-format off 137// clang-format off
273void render_logo(void) {
274 static const char PROGMEM qmk_logo[] = {
275 0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8a,0x8b,0x8c,0x8d,0x8e,0x8f,0x90,0x91,0x92,0x93,0x94,
276 0xa0,0xa1,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xab,0xac,0xad,0xae,0xaf,0xb0,0xb1,0xb2,0xb3,0xb4,
277 0xc0,0xc1,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xcb,0xcc,0xcd,0xce,0xcf,0xd0,0xd1,0xd2,0xd3,0xd4,0};
278
279 oled_write_P(qmk_logo, false);
280}
281 138
282# ifndef SPLIT_TRANSPORT_MIRROR 139# ifndef SPLIT_TRANSPORT_MIRROR
283void render_kyria_logo(void) { 140void oled_driver_render_logo(void) {
284 static const char PROGMEM kyria_logo[] = { 141 static const char PROGMEM kyria_logo[] = {
285 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,128,128,192,224,240,112,120, 56, 60, 28, 30, 14, 14, 14, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 14, 14, 14, 30, 28, 60, 56,120,112,240,224,192,128,128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 142 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,128,128,192,224,240,112,120, 56, 60, 28, 30, 14, 14, 14, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 14, 14, 14, 30, 28, 60, 56,120,112,240,224,192,128,128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
286 0, 0, 0, 0, 0, 0, 0,192,224,240,124, 62, 31, 15, 7, 3, 1,128,192,224,240,120, 56, 60, 28, 30, 14, 14, 7, 7,135,231,127, 31,255,255, 31,127,231,135, 7, 7, 14, 14, 30, 28, 60, 56,120,240,224,192,128, 1, 3, 7, 15, 31, 62,124,240,224,192, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 143 0, 0, 0, 0, 0, 0, 0,192,224,240,124, 62, 31, 15, 7, 3, 1,128,192,224,240,120, 56, 60, 28, 30, 14, 14, 7, 7,135,231,127, 31,255,255, 31,127,231,135, 7, 7, 14, 14, 30, 28, 60, 56,120,240,224,192,128, 1, 3, 7, 15, 31, 62,124,240,224,192, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
@@ -294,51 +151,6 @@ void render_kyria_logo(void) {
294 oled_write_raw_P(kyria_logo, sizeof(kyria_logo)); 151 oled_write_raw_P(kyria_logo, sizeof(kyria_logo));
295} 152}
296# endif 153# endif
297// clang-format on
298
299void render_status_main(void) {
300 /* Show Keyboard Layout */
301 render_default_layer_state();
302 render_keylock_status(host_keyboard_leds());
303 render_bootmagic_status();
304 render_user_status();
305
306 render_keylogger_status();
307}
308
309void render_status_secondary(void) {
310 /* Show Keyboard Layout */
311 render_logo();
312 render_default_layer_state();
313 render_layer_state();
314 render_mod_status(get_mods() | get_oneshot_mods());
315
316 render_keylogger_status();
317}
318
319void oled_task_user(void) {
320 if (timer_elapsed32(oled_timer) > 30000) {
321 oled_off();
322 return;
323 }
324# ifndef SPLIT_KEYBOARD
325 else {
326 oled_on();
327 }
328# endif
329
330 update_log();
331 if (is_master) {
332 render_status_main(); // Renders the current keyboard state (layer, lock, caps, scroll, etc)
333 } else {
334# ifdef SPLIT_TRANSPORT_MIRROR
335 render_status_secondary();
336# else
337 render_kyria_logo();
338# endif
339 }
340}
341
342#endif 154#endif
343 155
344#ifdef ENCODER_ENABLE 156#ifdef ENCODER_ENABLE
diff --git a/keyboards/kyria/keymaps/drashna/rules.mk b/keyboards/kyria/keymaps/drashna/rules.mk
index e835340bb..2486ecd5d 100644
--- a/keyboards/kyria/keymaps/drashna/rules.mk
+++ b/keyboards/kyria/keymaps/drashna/rules.mk
@@ -20,3 +20,5 @@ HD44780_ENABLE = no # Enable support for HD44780 based LCDs
20BOOTLOADER = atmel-dfu 20BOOTLOADER = atmel-dfu
21 21
22SPLIT_TRANSPORT = mirror 22SPLIT_TRANSPORT = mirror
23
24TAP_DANCE_ENABLE = yes
diff --git a/layouts/community/ergodox/drashna/config.h b/layouts/community/ergodox/drashna/config.h
index ce25b0646..8f1c9f6a2 100644
--- a/layouts/community/ergodox/drashna/config.h
+++ b/layouts/community/ergodox/drashna/config.h
@@ -15,7 +15,7 @@
15#define PRODUCT DrashnaDox - Hacked ErgoDox EZ Hybrid Monstrosity 15#define PRODUCT DrashnaDox - Hacked ErgoDox EZ Hybrid Monstrosity
16 16
17#undef DEBOUNCE 17#undef DEBOUNCE
18#define DEBOUNCE 30 18#define DEBOUNCE 60
19 19
20#define TAPPING_TERM_PER_KEY 20#define TAPPING_TERM_PER_KEY
21 21
diff --git a/layouts/community/ergodox/drashna/rules.mk b/layouts/community/ergodox/drashna/rules.mk
index 78a3d1584..387bd20f6 100644
--- a/layouts/community/ergodox/drashna/rules.mk
+++ b/layouts/community/ergodox/drashna/rules.mk
@@ -1,8 +1,7 @@
1BOOTMAGIC_ENABLE = lite 1BOOTMAGIC_ENABLE = lite
2TAP_DANCE_ENABLE = no 2TAP_DANCE_ENABLE = yes
3SLEEP_LED_ENABLE = no # Breathing sleep LED during USB suspend
4COMMAND_ENABLE = no # Commands for debug and configuration 3COMMAND_ENABLE = no # Commands for debug and configuration
5CONSOLE_ENABLE = no 4CONSOLE_ENABLE =
6SPACE_CADET_ENABLE = no 5SPACE_CADET_ENABLE = no
7 6
8ifeq ($(strip $(KEYBOARD)), ergodox_ez) 7ifeq ($(strip $(KEYBOARD)), ergodox_ez)
@@ -10,7 +9,7 @@ ifeq ($(strip $(KEYBOARD)), ergodox_ez)
10 RGB_MATRIX_ENABLE = yes 9 RGB_MATRIX_ENABLE = yes
11 RGBLIGHT_TWINKLE = no 10 RGBLIGHT_TWINKLE = no
12 INDICATOR_LIGHTS = no 11 INDICATOR_LIGHTS = no
13 RGBLIGHT_STARTUP_ANIMATION = no 12 RGBLIGHT_STARTUP_ANIMATION = yes
14endif 13endif
15 14
16UNICODE_ENABLE = yes 15UNICODE_ENABLE = yes
diff --git a/layouts/community/ortho_4x12/drashna/config.h b/layouts/community/ortho_4x12/drashna/config.h
index 663708afa..5342549e5 100644
--- a/layouts/community/ortho_4x12/drashna/config.h
+++ b/layouts/community/ortho_4x12/drashna/config.h
@@ -62,6 +62,8 @@
62# endif 62# endif
63#endif 63#endif
64 64
65#define EEPROM_I2C_RM24C512C
66
65#define ENCODER_DIRECTION_FLIP 67#define ENCODER_DIRECTION_FLIP
66/* 68/*
67 * MIDI options 69 * MIDI options
diff --git a/layouts/community/ortho_4x12/drashna/rules.mk b/layouts/community/ortho_4x12/drashna/rules.mk
index e4fe90534..3383cfd35 100644
--- a/layouts/community/ortho_4x12/drashna/rules.mk
+++ b/layouts/community/ortho_4x12/drashna/rules.mk
@@ -18,8 +18,10 @@ else
18 CONSOLE_ENABLE = yes 18 CONSOLE_ENABLE = yes
19 COMMAND_ENABLE = yes 19 COMMAND_ENABLE = yes
20 RGBLIGHT_ENABLE = yes 20 RGBLIGHT_ENABLE = yes
21 RGBLIGHT_STARTUP_ANIMATION = yes
21 RGB_MATRIX_ENABLE = no 22 RGB_MATRIX_ENABLE = no
22 AUDIO_ENABLE = yes 23 AUDIO_ENABLE = yes
24 EEPROM_DRIVER = i2c
23endif 25endif
24ifeq ($(strip $(KEYBOARD)), planck/light) 26ifeq ($(strip $(KEYBOARD)), planck/light)
25 RGB_MATRIX_ENABLE = yes 27 RGB_MATRIX_ENABLE = yes
diff --git a/users/drashna/config.h b/users/drashna/config.h
index 106ae19c1..64b4b64ab 100644
--- a/users/drashna/config.h
+++ b/users/drashna/config.h
@@ -1,7 +1,7 @@
1#pragma once 1#pragma once
2 2
3// Use custom magic number so that when switching branches, EEPROM always gets reset 3// Use custom magic number so that when switching branches, EEPROM always gets reset
4#define EECONFIG_MAGIC_NUMBER (uint16_t)0x1337 4#define EECONFIG_MAGIC_NUMBER (uint16_t)0x1338
5 5
6/* Set Polling rate to 1000Hz */ 6/* Set Polling rate to 1000Hz */
7#define USB_POLLING_INTERVAL_MS 1 7#define USB_POLLING_INTERVAL_MS 1
@@ -52,6 +52,7 @@
52# if defined(__AVR__) && !defined(__AVR_AT90USB1286__) 52# if defined(__AVR__) && !defined(__AVR_AT90USB1286__)
53# define DISABLE_RGB_MATRIX_ALPHAS_MODS 53# define DISABLE_RGB_MATRIX_ALPHAS_MODS
54# define DISABLE_RGB_MATRIX_GRADIENT_UP_DOWN 54# define DISABLE_RGB_MATRIX_GRADIENT_UP_DOWN
55# define DISABLE_RGB_MATRIX_GRADIENT_LEFT_RIGHT
55# define DISABLE_RGB_MATRIX_BREATHING 56# define DISABLE_RGB_MATRIX_BREATHING
56# define DISABLE_RGB_MATRIX_BAND_SAT 57# define DISABLE_RGB_MATRIX_BAND_SAT
57# define DISABLE_RGB_MATRIX_BAND_VAL 58# define DISABLE_RGB_MATRIX_BAND_VAL
diff --git a/users/drashna/drashna.c b/users/drashna/drashna.c
index 1a4ee9b41..ba19d4803 100644
--- a/users/drashna/drashna.c
+++ b/users/drashna/drashna.c
@@ -18,12 +18,6 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
18#include "drashna.h" 18#include "drashna.h"
19 19
20userspace_config_t userspace_config; 20userspace_config_t userspace_config;
21#if (defined(UNICODE_ENABLE) || defined(UNICODEMAP_ENABLE) || defined(UCIS_ENABLE))
22# define DRASHNA_UNICODE_MODE UC_WIN
23#else
24// set to 2 for UC_WIN, set to 4 for UC_WINC
25# define DRASHNA_UNICODE_MODE 2
26#endif
27 21
28bool mod_key_press_timer(uint16_t code, uint16_t mod_code, bool pressed) { 22bool mod_key_press_timer(uint16_t code, uint16_t mod_code, bool pressed) {
29 static uint16_t this_timer; 23 static uint16_t this_timer;
@@ -93,19 +87,17 @@ void matrix_init_user(void) {
93 DDRB &= ~(1 << 0); 87 DDRB &= ~(1 << 0);
94 PORTB &= ~(1 << 0); 88 PORTB &= ~(1 << 0);
95#endif 89#endif
96
97#if (defined(UNICODE_ENABLE) || defined(UNICODEMAP_ENABLE) || defined(UCIS_ENABLE))
98 set_unicode_input_mode(DRASHNA_UNICODE_MODE);
99 get_unicode_input_mode();
100#endif // UNICODE_ENABLE
101 matrix_init_keymap(); 90 matrix_init_keymap();
102} 91}
103 92
104__attribute__((weak)) void keyboard_post_init_keymap(void) {} 93__attribute__((weak)) void keyboard_post_init_keymap(void) {}
105 94
106void keyboard_post_init_user(void) { 95void keyboard_post_init_user(void) {
107#if defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE) 96#if defined(RGBLIGHT_ENABLE)
108 keyboard_post_init_rgb(); 97 keyboard_post_init_rgb_light();
98#endif
99#if defined(RGB_MATRIX_ENABLE)
100 keyboard_post_init_rgb_matrix();
109#endif 101#endif
110 keyboard_post_init_keymap(); 102 keyboard_post_init_keymap();
111} 103}
@@ -155,9 +147,12 @@ void matrix_scan_user(void) {
155 run_diablo_macro_check(); 147 run_diablo_macro_check();
156#endif // TAP_DANCE_ENABLE 148#endif // TAP_DANCE_ENABLE
157 149
158#if defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE) 150#if defined(RGBLIGHT_ENABLE)
159 matrix_scan_rgb(); 151 matrix_scan_rgb_light();
160#endif // RGBLIGHT_ENABLE 152#endif // RGBLIGHT_ENABLE
153#if defined(RGB_MATRIX_ENABLE)
154 matrix_scan_rgb_matrix();
155#endif
161 156
162 matrix_scan_keymap(); 157 matrix_scan_keymap();
163} 158}
@@ -168,8 +163,8 @@ __attribute__((weak)) layer_state_t layer_state_set_keymap(layer_state_t state)
168// Then runs keymap's layer change check 163// Then runs keymap's layer change check
169layer_state_t layer_state_set_user(layer_state_t state) { 164layer_state_t layer_state_set_user(layer_state_t state) {
170 state = update_tri_layer_state(state, _RAISE, _LOWER, _ADJUST); 165 state = update_tri_layer_state(state, _RAISE, _LOWER, _ADJUST);
171#if defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE) 166#if defined(RGBLIGHT_ENABLE)
172 state = layer_state_set_rgb(state); 167 state = layer_state_set_rgb_light(state);
173#endif // RGBLIGHT_ENABLE 168#endif // RGBLIGHT_ENABLE
174 return layer_state_set_keymap(state); 169 return layer_state_set_keymap(state);
175} 170}
@@ -200,12 +195,6 @@ void eeconfig_init_user(void) {
200 userspace_config.raw = 0; 195 userspace_config.raw = 0;
201 userspace_config.rgb_layer_change = true; 196 userspace_config.rgb_layer_change = true;
202 eeconfig_update_user(userspace_config.raw); 197 eeconfig_update_user(userspace_config.raw);
203#if (defined(UNICODE_ENABLE) || defined(UNICODEMAP_ENABLE) || defined(UCIS_ENABLE))
204 set_unicode_input_mode(DRASHNA_UNICODE_MODE);
205 get_unicode_input_mode();
206#else
207 eeprom_update_byte(EECONFIG_UNICODEMODE, DRASHNA_UNICODE_MODE);
208#endif
209 eeconfig_init_keymap(); 198 eeconfig_init_keymap();
210 keyboard_init(); 199 keyboard_init();
211} 200}
diff --git a/users/drashna/drashna.h b/users/drashna/drashna.h
index 0ba181760..c10ea5114 100644
--- a/users/drashna/drashna.h
+++ b/users/drashna/drashna.h
@@ -25,9 +25,15 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
25#ifdef TAP_DANCE_ENABLE 25#ifdef TAP_DANCE_ENABLE
26# include "tap_dances.h" 26# include "tap_dances.h"
27#endif // TAP_DANCE_ENABLE 27#endif // TAP_DANCE_ENABLE
28#if defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE) 28#if defined(RGBLIGHT_ENABLE)
29# include "rgb_stuff.h" 29# include "rgb_stuff.h"
30#endif 30#endif
31#if defined(RGB_MATRIX_ENABLE)
32# include "rgb_matrix_stuff.h"
33#endif
34#if defined(OLED_DRIVER_ENABLE)
35# include "oled_stuff.h"
36#endif
31 37
32/* Define layer names */ 38/* Define layer names */
33enum userspace_layers { 39enum userspace_layers {
@@ -70,7 +76,6 @@ typedef union {
70 bool rgb_layer_change :1; 76 bool rgb_layer_change :1;
71 bool is_overwatch :1; 77 bool is_overwatch :1;
72 bool nuke_switch :1; 78 bool nuke_switch :1;
73 uint8_t unicode_mod :4;
74 bool swapped_numbers :1; 79 bool swapped_numbers :1;
75 bool rgb_matrix_idle_anim :1; 80 bool rgb_matrix_idle_anim :1;
76 }; 81 };
diff --git a/users/drashna/oled_stuff.c b/users/drashna/oled_stuff.c
new file mode 100644
index 000000000..7580de1d3
--- /dev/null
+++ b/users/drashna/oled_stuff.c
@@ -0,0 +1,278 @@
1#include "drashna.h"
2
3extern uint8_t is_master;
4
5#ifndef KEYLOGGER_LENGTH
6// # ifdef OLED_DISPLAY_128X64
7# define KEYLOGGER_LENGTH ((int)(OLED_DISPLAY_HEIGHT / OLED_FONT_WIDTH))
8// # else
9// # define KEYLOGGER_LENGTH (uint8_t *(OLED_DISPLAY_WIDTH / OLED_FONT_HEIGHT))
10// # endif
11#endif
12
13static uint32_t oled_timer = 0;
14static char keylog_str[KEYLOGGER_LENGTH + 1] = {"\n"};
15static uint16_t log_timer = 0;
16
17// clang-format off
18static const char PROGMEM code_to_name[0xFF] = {
19// 0 1 2 3 4 5 6 7 8 9 A B c D E F
20 ' ', ' ', ' ', ' ', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', // 0x
21 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '1', '2', // 1x
22 '3', '4', '5', '6', '7', '8', '9', '0', 20, 19, 27, 26, 22, '-', '=', '[', // 2x
23 ']','\\', '#', ';','\'', '`', ',', '.', '/', 128, ' ', ' ', ' ', ' ', ' ', ' ', // 3x
24 ' ', ' ', ' ', ' ', ' ', ' ', 'P', 'S', ' ', ' ', ' ', ' ', 16, ' ', ' ', ' ', // 4x
25 ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', // 5x
26 ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', // 6x
27 ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', // 7x
28 ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', // 8x
29 ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', // 9x
30 ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', // Ax
31 ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', // Bx
32 ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', // Cx
33 ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', // Dx
34 'C', 'S', 'A', 'C', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', // Ex
35 ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ' // Fx
36};
37// clang-format on
38
39void add_keylog(uint16_t keycode) {
40 if ((keycode >= QK_MOD_TAP && keycode <= QK_MOD_TAP_MAX) || (keycode >= QK_LAYER_TAP && keycode <= QK_LAYER_TAP_MAX) || (keycode >= QK_MODS && keycode <= QK_MODS_MAX)) {
41 keycode = keycode & 0xFF;
42 } else if (keycode > 0xFF) {
43 keycode = 0;
44 }
45
46 for (uint8_t i = (KEYLOGGER_LENGTH - 1); i > 0; --i) {
47 keylog_str[i] = keylog_str[i - 1];
48 }
49
50 if (keycode < (sizeof(code_to_name) / sizeof(char))) {
51 keylog_str[0] = pgm_read_byte(&code_to_name[keycode]);
52 }
53
54 log_timer = timer_read();
55}
56
57bool process_record_user_oled(uint16_t keycode, keyrecord_t *record) {
58 if (record->event.pressed) {
59#ifdef OLED_DRIVER_ENABLE
60 oled_timer = timer_read32();
61 add_keylog(keycode);
62#endif
63 }
64 return true;
65}
66
67void update_log(void) {
68 if (timer_elapsed(log_timer) > 750) {
69 // add_keylog(0);
70 }
71}
72
73void render_keylogger_status(void) {
74 oled_write_P(PSTR(OLED_RENDER_KEYLOGGER), false);
75 oled_write(keylog_str, false);
76}
77
78void render_default_layer_state(void) {
79 oled_write_P(PSTR(OLED_RENDER_LAYOUT_NAME), false);
80 switch (get_highest_layer(default_layer_state)) {
81 case _QWERTY:
82 oled_write_P(PSTR(OLED_RENDER_LAYOUT_QWERTY), false);
83 break;
84 case _COLEMAK:
85 oled_write_P(PSTR(OLED_RENDER_LAYOUT_COLEMAK), false);
86 break;
87 case _DVORAK:
88 oled_write_P(PSTR(OLED_RENDER_LAYOUT_DVORAK), false);
89 break;
90 case _WORKMAN:
91 oled_write_P(PSTR(OLED_RENDER_LAYOUT_WORKMAN), false);
92 break;
93 case _NORMAN:
94 oled_write_P(PSTR(OLED_RENDER_LAYOUT_NORMAN), false);
95 break;
96 case _MALTRON:
97 oled_write_P(PSTR(OLED_RENDER_LAYOUT_MALTRON), false);
98 break;
99 case _EUCALYN:
100 oled_write_P(PSTR(OLED_RENDER_LAYOUT_EUCALYN), false);
101 break;
102 case _CARPLAX:
103 oled_write_P(PSTR(OLED_RENDER_LAYOUT_CARPLAX), false);
104 break;
105 }
106#ifdef OLED_DISPLAY_128X64
107 oled_advance_page(true);
108#endif
109}
110
111void render_layer_state(void) {
112 oled_write_P(PSTR(OLED_RENDER_LAYER_NAME), false);
113#ifdef OLED_DISPLAY_128X64
114 oled_write_P(PSTR(" "), false);
115#endif
116 oled_write_P(PSTR(OLED_RENDER_LAYER_LOWER), layer_state_is(_LOWER));
117#ifdef OLED_DISPLAY_128X64
118 oled_write_P(PSTR(" "), false);
119#endif
120 oled_write_P(PSTR(OLED_RENDER_LAYER_RAISE), layer_state_is(_RAISE));
121#if _MODS
122# ifdef OLED_DISPLAY_128X64
123 oled_write_P(PSTR(" "), false);
124# endif
125 oled_write_P(PSTR(OLED_RENDER_LAYER_MODS), layer_state_is(_MODS));
126#endif
127#ifdef OLED_DISPLAY_128X64
128 oled_advance_page(true);
129#endif
130}
131
132void render_keylock_status(uint8_t led_usb_state) {
133 oled_write_P(PSTR(OLED_RENDER_LOCK_NAME), false);
134 oled_write_P(PSTR(" "), false);
135 oled_write_P(PSTR(OLED_RENDER_LOCK_NUML), led_usb_state & (1 << USB_LED_NUM_LOCK));
136#ifdef OLED_DISPLAY_128X64
137 oled_write_P(PSTR(" "), false);
138#endif
139 oled_write_P(PSTR(OLED_RENDER_LOCK_CAPS), led_usb_state & (1 << USB_LED_CAPS_LOCK));
140#ifdef OLED_DISPLAY_128X64
141 oled_write_P(PSTR(" "), false);
142#endif
143 oled_write_P(PSTR(OLED_RENDER_LOCK_SCLK), led_usb_state & (1 << USB_LED_SCROLL_LOCK));
144#ifndef OLED_DISPLAY_128X64
145 oled_advance_page(true);
146#endif
147}
148
149void render_mod_status(uint8_t modifiers) {
150 oled_write_P(PSTR(OLED_RENDER_MODS_NAME), false);
151 oled_write_P(PSTR(OLED_RENDER_MODS_SFT), (modifiers & MOD_MASK_SHIFT));
152#ifdef OLED_DISPLAY_128X64
153 oled_write_P(PSTR(" "), false);
154#endif
155 oled_write_P(PSTR(OLED_RENDER_MODS_CTL), (modifiers & MOD_MASK_CTRL));
156#ifdef OLED_DISPLAY_128X64
157 oled_write_P(PSTR(" "), false);
158#endif
159 oled_write_P(PSTR(OLED_RENDER_MODS_ALT), (modifiers & MOD_MASK_ALT));
160#ifdef OLED_DISPLAY_128X64
161 oled_write_P(PSTR(" "), false);
162#endif
163 oled_write_P(PSTR(OLED_RENDER_MODS_GUI), (modifiers & MOD_MASK_GUI));
164}
165
166void render_bootmagic_status(void) {
167 /* Show Ctrl-Gui Swap options */
168 static const char PROGMEM logo[][2][3] = {
169 {{0x97, 0x98, 0}, {0xb7, 0xb8, 0}},
170 {{0x95, 0x96, 0}, {0xb5, 0xb6, 0}},
171 };
172
173 oled_write_P(PSTR(OLED_RENDER_BOOTMAGIC_NAME), false);
174#ifdef OLED_DISPLAY_128X64
175 if (keymap_config.swap_lctl_lgui)
176#else
177 oled_write_P(PSTR(" "), false);
178#endif
179 {
180 oled_write_P(logo[1][0], false);
181#ifdef OLED_DISPLAY_128X64
182 } else {
183#endif
184 oled_write_P(logo[0][0], false);
185 }
186 oled_write_P(PSTR(" "), false);
187#ifdef OLED_DISPLAY_128X64
188 oled_write_P(PSTR(OLED_RENDER_BOOTMAGIC_NKRO), keymap_config.nkro);
189 oled_write_P(PSTR(" "), false);
190 oled_write_ln_P(PSTR(OLED_RENDER_BOOTMAGIC_NOGUI), !keymap_config.no_gui);
191 oled_write_P(PSTR("Magic "), false);
192 if (keymap_config.swap_lctl_lgui)
193#endif
194 {
195 oled_write_P(logo[1][1], false);
196#ifdef OLED_DISPLAY_128X64
197 } else {
198#endif
199 oled_write_P(logo[0][1], false);
200 }
201 oled_write_P(PSTR(" "), false);
202#ifdef OLED_DISPLAY_128X64
203 oled_write_P(PSTR(OLED_RENDER_BOOTMAGIC_GRV), keymap_config.swap_grave_esc);
204 oled_write_P(PSTR(" "), false);
205 oled_write_P(PSTR(OLED_RENDER_BOOTMAGIC_CAPS), keymap_config.swap_control_capslock);
206 oled_advance_page(true);
207#else
208 oled_write_P(PSTR(OLED_RENDER_BOOTMAGIC_NKRO), keymap_config.nkro);
209#endif
210}
211
212void render_user_status(void) {
213 oled_write_P(PSTR(OLED_RENDER_USER_NAME), false);
214 oled_write_P(PSTR(" "), false);
215 oled_write_P(PSTR(OLED_RENDER_USER_ANIM), userspace_config.rgb_matrix_idle_anim);
216 oled_write_P(PSTR(" "), false);
217 oled_write_P(PSTR(OLED_RENDER_USER_LAYR), userspace_config.rgb_layer_change);
218 oled_write_P(PSTR(" "), false);
219 oled_write_P(PSTR(OLED_RENDER_USER_NUKE), userspace_config.nuke_switch);
220#ifdef OLED_DISPLAY_128X64
221 oled_advance_page(true);
222#endif
223}
224
225__attribute__((weak)) void oled_driver_render_logo(void) {
226 // clang-format off
227 static const char PROGMEM qmk_logo[] = {
228 0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8a,0x8b,0x8c,0x8d,0x8e,0x8f,0x90,0x91,0x92,0x93,0x94,
229 0xa0,0xa1,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xab,0xac,0xad,0xae,0xaf,0xb0,0xb1,0xb2,0xb3,0xb4,
230 0xc0,0xc1,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xcb,0xcc,0xcd,0xce,0xcf,0xd0,0xd1,0xd2,0xd3,0xd4,0};
231 // clang-format on
232 oled_write_P(qmk_logo, false);
233}
234
235void render_status_secondary(void) {
236#if !defined(SPLIT_TRANSPORT_MIRROR) || defined(OLED_DRIVER_128x64)
237 oled_driver_render_logo();
238#endif
239#ifdef SPLIT_TRANSPORT_MIRROR
240 /* Show Keyboard Layout */
241 render_default_layer_state();
242 render_layer_state();
243 render_mod_status(get_mods() | get_oneshot_mods());
244 render_keylogger_status();
245
246#endif
247}
248// clang-format on
249
250void render_status_main(void) {
251 /* Show Keyboard Layout */
252 render_default_layer_state();
253 render_keylock_status(host_keyboard_leds());
254 render_bootmagic_status();
255 render_user_status();
256
257 render_keylogger_status();
258}
259
260void oled_task_user(void) {
261 if (timer_elapsed32(oled_timer) > 30000) {
262 oled_off();
263 return;
264 }
265#ifndef SPLIT_KEYBOARD
266 else {
267 oled_on();
268 }
269#endif
270
271 update_log();
272
273 if (is_master) {
274 render_status_main(); // Renders the current keyboard state (layer, lock, caps, scroll, etc)
275 } else {
276 render_status_secondary();
277 }
278}
diff --git a/users/drashna/oled_stuff.h b/users/drashna/oled_stuff.h
new file mode 100644
index 000000000..662e206b7
--- /dev/null
+++ b/users/drashna/oled_stuff.h
@@ -0,0 +1,91 @@
1#pragma once
2
3#include "quantum.h"
4#include "oled_driver.h"
5
6void oled_driver_render_logo(void);
7bool process_record_user_oled(uint16_t keycode, keyrecord_t *record);
8
9#ifdef OLED_DISPLAY_128X64
10# define OLED_RENDER_KEYLOGGER "Keylogger: "
11
12# define OLED_RENDER_LAYOUT_NAME "Layout: "
13# define OLED_RENDER_LAYOUT_QWERTY "Qwerty"
14# define OLED_RENDER_LAYOUT_COLEMAK "Colemak"
15# define OLED_RENDER_LAYOUT_DVORAK "Dvorak"
16# define OLED_RENDER_LAYOUT_WORKMAN "Workman"
17# define OLED_RENDER_LAYOUT_NORMAN "Norman"
18# define OLED_RENDER_LAYOUT_MALTRON "Matron"
19# define OLED_RENDER_LAYOUT_EUCALYN "Eucalyn"
20# define OLED_RENDER_LAYOUT_CARPLAX "Carplax"
21
22# define OLED_RENDER_LAYER_NAME "Layer:\n"
23# define OLED_RENDER_LAYER_LOWER "Lower"
24# define OLED_RENDER_LAYER_RAISE "Raise"
25# define OLED_RENDER_LAYER_ADJUST "Adjust"
26# define OLED_RENDER_LAYER_MODS "Mods"
27
28# define OLED_RENDER_LOCK_NAME "Lock: "
29# define OLED_RENDER_LOCK_NUML "NUML"
30# define OLED_RENDER_LOCK_CAPS "CAPS"
31# define OLED_RENDER_LOCK_SCLK "SCLK"
32
33# define OLED_RENDER_MODS_NAME "Mods: "
34# define OLED_RENDER_MODS_SFT "Sft"
35# define OLED_RENDER_MODS_CTL "Ctl"
36# define OLED_RENDER_MODS_ALT "Alt"
37# define OLED_RENDER_MODS_GUI "GUI"
38
39# define OLED_RENDER_BOOTMAGIC_NAME "Boot "
40# define OLED_RENDER_BOOTMAGIC_NKRO "NKRO"
41# define OLED_RENDER_BOOTMAGIC_NOGUI "nGUI"
42# define OLED_RENDER_BOOTMAGIC_GRV "GRV"
43# define OLED_RENDER_BOOTMAGIC_CAPS "CAPS"
44
45# define OLED_RENDER_USER_NAME "USER:"
46# define OLED_RENDER_USER_ANIM "Anim"
47# define OLED_RENDER_USER_LAYR "Layr"
48# define OLED_RENDER_USER_NUKE "Nuke"
49
50#else
51# define OLED_RENDER_KEYLOGGER "KLogr"
52
53# define OLED_RENDER_LAYOUT_NAME "Lyout"
54# define OLED_RENDER_LAYOUT_QWERTY " QRTY"
55# define OLED_RENDER_LAYOUT_COLEMAK " COLE"
56# define OLED_RENDER_LAYOUT_DVORAK " DVRK"
57# define OLED_RENDER_LAYOUT_WORKMAN " WKMN"
58# define OLED_RENDER_LAYOUT_NORMAN " NORM"
59# define OLED_RENDER_LAYOUT_MALTRON " MLTN"
60# define OLED_RENDER_LAYOUT_EUCALYN " ECLN"
61# define OLED_RENDER_LAYOUT_CARPLAX " CRPX"
62
63# define OLED_RENDER_LAYER_NAME "LAYER"
64# define OLED_RENDER_LAYER_LOWER "Lower"
65# define OLED_RENDER_LAYER_RAISE "Raise"
66# define OLED_RENDER_LAYER_ADJUST "Adjst"
67# define OLED_RENDER_LAYER_MODS " Mods"
68
69# define OLED_RENDER_LOCK_NAME "Lock:"
70# define OLED_RENDER_LOCK_NUML "N"
71# define OLED_RENDER_LOCK_CAPS "C"
72# define OLED_RENDER_LOCK_SCLK "S"
73
74# define OLED_RENDER_MODS_NAME "Mods: "
75# define OLED_RENDER_MODS_SFT "S"
76# define OLED_RENDER_MODS_CTL "C"
77# define OLED_RENDER_MODS_ALT "A"
78# define OLED_RENDER_MODS_GUI "G"
79
80# define OLED_RENDER_BOOTMAGIC_NAME "BTMGK"
81# define OLED_RENDER_BOOTMAGIC_NKRO "NKRO"
82# define OLED_RENDER_BOOTMAGIC_NOGUI "nGUI"
83# define OLED_RENDER_BOOTMAGIC_GRV "GRV"
84# define OLED_RENDER_BOOTMAGIC_CAPS "CAPS"
85
86# define OLED_RENDER_USER_NAME "USER:"
87# define OLED_RENDER_USER_ANIM "Anim"
88# define OLED_RENDER_USER_LAYR "Layr"
89# define OLED_RENDER_USER_NUKE "Nuke"
90
91#endif
diff --git a/users/drashna/process_records.c b/users/drashna/process_records.c
index af3ee9cf0..101b3d95c 100644
--- a/users/drashna/process_records.c
+++ b/users/drashna/process_records.c
@@ -17,101 +17,308 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
17 xprintf("KL: kc: %u, col: %u, row: %u, pressed: %u\n", keycode, record->event.key.col, record->event.key.row, record->event.pressed); 17 xprintf("KL: kc: %u, col: %u, row: %u, pressed: %u\n", keycode, record->event.key.col, record->event.key.row, record->event.pressed);
18# endif 18# endif
19#endif // KEYLOGGER_ENABLE 19#endif // KEYLOGGER_ENABLE
20#ifdef OLED_DRIVER_ENABLE
21 process_record_user_oled(keycode, record);
22#endif // OLED
20 23
21 switch (keycode) { 24 if (process_record_keymap(keycode, record) && process_record_secrets(keycode, record)
22 case KC_QWERTY ... KC_WORKMAN: 25#ifdef RGB_MATRIX_ENABLE
23 if (record->event.pressed) { 26 && process_record_user_rgb_matrix(keycode, record)
24 uint8_t mods = mod_config(get_mods() | get_oneshot_mods()); 27#endif
25 if (!mods) { 28#ifdef RGBLIGHT_ENABLE
26 set_single_persistent_default_layer(keycode - KC_QWERTY); 29 && process_record_user_rgb_light(keycode, record)
27 } else if (mods & MOD_MASK_SHIFT) { 30#endif
28 set_single_persistent_default_layer(keycode - KC_QWERTY + 4); 31 ) {
29 } else if (mods & MOD_MASK_CTRL) { 32 switch (keycode) {
30 set_single_persistent_default_layer(keycode - KC_QWERTY + 8); 33 case KC_QWERTY ... KC_WORKMAN:
34 if (record->event.pressed) {
35 uint8_t mods = mod_config(get_mods() | get_oneshot_mods());
36 if (!mods) {
37 set_single_persistent_default_layer(keycode - KC_QWERTY);
38 } else if (mods & MOD_MASK_SHIFT) {
39 set_single_persistent_default_layer(keycode - KC_QWERTY + 4);
40 } else if (mods & MOD_MASK_CTRL) {
41 set_single_persistent_default_layer(keycode - KC_QWERTY + 8);
42 }
31 } 43 }
32 } 44 break;
33 break;
34 45
35 case KC_MAKE: // Compiles the firmware, and adds the flash command based on keyboard bootloader 46 case KC_MAKE: // Compiles the firmware, and adds the flash command based on keyboard bootloader
36 if (!record->event.pressed) { 47 if (!record->event.pressed) {
37 uint8_t temp_mod = mod_config(get_mods());
38 uint8_t temp_osm = mod_config(get_oneshot_mods());
39 clear_mods();
40 clear_oneshot_mods();
41 send_string_with_delay_P(PSTR("make " QMK_KEYBOARD ":" QMK_KEYMAP), TAP_CODE_DELAY);
42#ifndef MAKE_BOOTLOADER 48#ifndef MAKE_BOOTLOADER
43 if ((temp_mod | temp_osm) & MOD_MASK_SHIFT) 49 uint8_t temp_mod = mod_config(get_mods());
50 uint8_t temp_osm = mod_config(get_oneshot_mods());
51 clear_mods();
52 clear_oneshot_mods();
44#endif 53#endif
45 { 54 send_string_with_delay_P(PSTR("bin/qmk"), TAP_CODE_DELAY);
46 send_string_with_delay_P(PSTR(":flash"), TAP_CODE_DELAY); 55#ifndef MAKE_BOOTLOADER
47 } 56 if ((temp_mod | temp_osm) & MOD_MASK_SHIFT)
48 if ((temp_mod | temp_osm) & MOD_MASK_CTRL) { 57#endif
49 send_string_with_delay_P(PSTR(" -j8 --output-sync"), TAP_CODE_DELAY); 58 {
50 } 59 send_string_with_delay_P(PSTR(" flash "), TAP_CODE_DELAY);
60#ifndef MAKE_BOOTLOADER
61 } else {
62 send_string_with_delay_P(PSTR(" compile "), TAP_CODE_DELAY);
63#endif
64 }
65 send_string_with_delay_P(PSTR("-kb " QMK_KEYBOARD " -km " QMK_KEYMAP), TAP_CODE_DELAY);
51#ifdef RGB_MATRIX_SPLIT_RIGHT 66#ifdef RGB_MATRIX_SPLIT_RIGHT
52 send_string_with_delay_P(PSTR(" RGB_MATRIX_SPLIT_RIGHT=yes"), TAP_CODE_DELAY); 67 send_string_with_delay_P(PSTR(" RGB_MATRIX_SPLIT_RIGHT=yes"), TAP_CODE_DELAY);
53# ifndef OLED_DRIVER_ENABLE 68# ifndef OLED_DRIVER_ENABLE
54 send_string_with_delay_P(PSTR(" OLED_DRIVER_ENABLE=no"), TAP_CODE_DELAY); 69 send_string_with_delay_P(PSTR(" OLED_DRIVER_ENABLE=no"), TAP_CODE_DELAY);
55# endif 70# endif
56#endif 71#endif
57 send_string_with_delay_P(PSTR(SS_TAP(X_ENTER)), TAP_CODE_DELAY); 72 send_string_with_delay_P(PSTR(SS_TAP(X_ENTER)), TAP_CODE_DELAY);
58 } 73 }
59 74
60 break; 75 break;
61 76
62 case VRSN: // Prints firmware version 77 case VRSN: // Prints firmware version
63 if (record->event.pressed) { 78 if (record->event.pressed) {
64 send_string_with_delay_P(PSTR(QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION ", Built on: " QMK_BUILDDATE), TAP_CODE_DELAY); 79 send_string_with_delay_P(PSTR(QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION ", Built on: " QMK_BUILDDATE), TAP_CODE_DELAY);
65 } 80 }
66 break; 81 break;
67 82
68 case KC_DIABLO_CLEAR: // reset all Diablo timers, disabling them 83 case KC_DIABLO_CLEAR: // reset all Diablo timers, disabling them
69#ifdef TAP_DANCE_ENABLE 84#ifdef TAP_DANCE_ENABLE
70 if (record->event.pressed) { 85 if (record->event.pressed) {
71 for (uint8_t index = 0; index < 4; index++) { 86 for (uint8_t index = 0; index < 4; index++) {
72 diablo_timer[index].key_interval = 0; 87 diablo_timer[index].key_interval = 0;
88 }
73 } 89 }
74 }
75#endif // TAP_DANCE_ENABLE 90#endif // TAP_DANCE_ENABLE
76 break; 91 break;
77 92
78 case KC_CCCV: // One key copy/paste 93 case KC_CCCV: // One key copy/paste
79 if (record->event.pressed) { 94 if (record->event.pressed) {
80 copy_paste_timer = timer_read(); 95 copy_paste_timer = timer_read();
81 } else { 96 } else {
82 if (timer_elapsed(copy_paste_timer) > TAPPING_TERM) { // Hold, copy 97 if (timer_elapsed(copy_paste_timer) > TAPPING_TERM) { // Hold, copy
83 tap_code16(LCTL(KC_C)); 98 tap_code16(LCTL(KC_C));
84 } else { // Tap, paste 99 } else { // Tap, paste
85 tap_code16(LCTL(KC_V)); 100 tap_code16(LCTL(KC_V));
101 }
86 } 102 }
87 } 103 break;
88 break;
89#ifdef UNICODE_ENABLE 104#ifdef UNICODE_ENABLE
90 case UC_FLIP: // (ノಠ痊ಠ)ノ彡┻━┻ 105 case UC_FLIP: // (ノಠ痊ಠ)ノ彡┻━┻
91 if (record->event.pressed) { 106 if (record->event.pressed) {
92 send_unicode_hex_string("0028 30CE 0CA0 75CA 0CA0 0029 30CE 5F61 253B 2501 253B"); 107 send_unicode_string("(ノಠ痊ಠ)ノ彡┻━┻");
93 } 108 }
94 break; 109 break;
95 case UC_TABL: // ┬─┬ノ( º _ ºノ) 110 case UC_TABL: // ┬─┬ノ( º _ ºノ)
96 if (record->event.pressed) { 111 if (record->event.pressed) {
97 send_unicode_hex_string("252C 2500 252C 30CE 0028 0020 00BA 0020 005F 0020 00BA 30CE 0029"); 112 send_unicode_string("┬─┬ノ( º _ ºノ)");
98 } 113 }
99 break; 114 break;
100 case UC_SHRG: // ¯\_(ツ)_/¯ 115 case UC_SHRG: // ¯\_(ツ)_/¯
101 if (record->event.pressed) { 116 if (record->event.pressed) {
102 send_unicode_hex_string("00AF 005C 005F 0028 30C4 0029 005F 002F 00AF"); 117 send_unicode_string("¯\\_(ツ)_/¯");
103 } 118 }
104 break; 119 break;
105 case UC_DISA: // ಠ_ಠ 120 case UC_DISA: // ಠ_ಠ
106 if (record->event.pressed) { 121 if (record->event.pressed) {
107 send_unicode_hex_string("0CA0 005F 0CA0"); 122 send_unicode_string("ಠ_ಠ");
108 } 123 }
109 break; 124 break;
110#endif 125#endif
111 } 126 case KC_RGB_T: // This allows me to use underglow as layer indication, or as normal
112 return process_record_keymap(keycode, record) &&
113#if defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE) 127#if defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE)
114 process_record_user_rgb(keycode, record) && 128 if (record->event.pressed) {
129 userspace_config.rgb_layer_change ^= 1;
130 dprintf("rgblight layer change [EEPROM]: %u\n", userspace_config.rgb_layer_change);
131 eeconfig_update_user(userspace_config.raw);
132 if (userspace_config.rgb_layer_change) {
133# if defined(RGBLIGHT_ENABLE) && defined(RGB_MATRIX_ENABLE)
134 rgblight_enable_noeeprom();
135# endif
136 layer_state_set(layer_state); // This is needed to immediately set the layer color (looks better)
137# if defined(RGBLIGHT_ENABLE) && defined(RGB_MATRIX_ENABLE)
138 } else {
139 rgblight_disable_noeeprom();
140# endif
141 }
142 }
115#endif // RGBLIGHT_ENABLE 143#endif // RGBLIGHT_ENABLE
116 process_record_secrets(keycode, record); 144 break;
145
146#if defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE)
147 case RGB_TOG:
148 // Split keyboards need to trigger on key-up for edge-case issue
149# ifndef SPLIT_KEYBOARD
150 if (record->event.pressed) {
151# else
152 if (!record->event.pressed) {
153# endif
154# if defined(RGBLIGHT_ENABLE) && !defined(RGBLIGHT_DISABLE_KEYCODES)
155 rgblight_toggle();
156# endif
157# if defined(RGB_MATRIX_ENABLE) && !defined(RGB_MATRIX_DISABLE_KEYCODES)
158 rgb_matrix_toggle();
159# endif
160 }
161 return false;
162 break;
163 case RGB_MODE_FORWARD ... RGB_MODE_GRADIENT: // quantum_keycodes.h L400 for definitions
164 if (record->event.pressed) {
165 bool is_eeprom_updated;
166# if defined(RGBLIGHT_ENABLE) && !defined(RGBLIGHT_DISABLE_KEYCODES)
167 // This disables layer indication, as it's assumed that if you're changing this ... you want that disabled
168 if (userspace_config.rgb_layer_change) {
169 userspace_config.rgb_layer_change = false;
170 dprintf("rgblight layer change [EEPROM]: %u\n", userspace_config.rgb_layer_change);
171 is_eeprom_updated = true;
172 }
173# endif
174# if defined(RGB_MATRIX_ENABLE) && defined(RGB_MATRIX_FRAMEBUFFER_EFFECTS)
175 if (userspace_config.rgb_matrix_idle_anim) {
176 userspace_config.rgb_matrix_idle_anim = false;
177 dprintf("RGB Matrix Idle Animation [EEPROM]: %u\n", userspace_config.rgb_matrix_idle_anim);
178 is_eeprom_updated = true;
179 }
180# endif
181 if (is_eeprom_updated) {
182 eeconfig_update_user(userspace_config.raw);
183 }
184 }
185
186# if defined(RGBLIGHT_DISABLE_KEYCODES) || defined(RGB_MATRIX_DISABLE_KEYCODES)
187 if (keycode == RGB_MODE_FORWARD && record->event.pressed) {
188 uint8_t shifted = get_mods() & (MOD_MASK_SHIFT);
189 if (shifted) {
190# if defined(RGBLIGHT_ENABLE) && !defined(RGBLIGHT_DISABLE_KEYCODES)
191 rgblight_step_reverse();
192# endif
193# if defined(RGB_MATRIX_ENABLE) && !defined(RGB_MATRIX_DISABLE_KEYCODES)
194 rgb_matrix_step_reverse();
195# endif
196 } else {
197# if defined(RGBLIGHT_ENABLE) && !defined(RGBLIGHT_DISABLE_KEYCODES)
198 rgblight_step();
199# endif
200# if defined(RGB_MATRIX_ENABLE) && !defined(RGB_MATRIX_DISABLE_KEYCODES)
201 rgb_matrix_step();
202# endif
203 }
204 } else if (keycode == RGB_MODE_REVERSE && record->event.pressed) {
205 uint8_t shifted = get_mods() & (MOD_MASK_SHIFT);
206 if (shifted) {
207# if defined(RGBLIGHT_ENABLE) && !defined(RGBLIGHT_DISABLE_KEYCODES)
208 rgblight_step();
209# endif
210# if defined(RGB_MATRIX_ENABLE) && !defined(RGB_MATRIX_DISABLE_KEYCODES)
211 rgb_matrix_step();
212# endif
213 } else {
214# if defined(RGBLIGHT_ENABLE) && !defined(RGBLIGHT_DISABLE_KEYCODES)
215 rgblight_step_reverse();
216# endif
217# if defined(RGB_MATRIX_ENABLE) && !defined(RGB_MATRIX_DISABLE_KEYCODES)
218 rgb_matrix_step_reverse();
219# endif
220 }
221 } else if (keycode == RGB_HUI) {
222# ifndef SPLIT_KEYBOARD
223 if (record->event.pressed) {
224# else
225 if (!record->event.pressed) {
226# endif
227# if defined(RGBLIGHT_ENABLE) && !defined(RGBLIGHT_DISABLE_KEYCODES)
228 rgblight_increase_hue();
229# endif
230# if defined(RGB_MATRIX_ENABLE) && !defined(RGB_MATRIX_DISABLE_KEYCODES)
231 rgb_matrix_increase_hue();
232# endif
233 }
234 } else if (keycode == RGB_HUD) {
235# ifndef SPLIT_KEYBOARD
236 if (record->event.pressed) {
237# else
238 if (!record->event.pressed) {
239# endif
240# if defined(RGBLIGHT_ENABLE) && !defined(RGBLIGHT_DISABLE_KEYCODES)
241 rgblight_decrease_hue();
242# endif
243# if defined(RGB_MATRIX_ENABLE) && !defined(RGB_MATRIX_DISABLE_KEYCODES)
244 rgb_matrix_decrease_hue();
245# endif
246 }
247 } else if (keycode == RGB_SAI) {
248# ifndef SPLIT_KEYBOARD
249 if (record->event.pressed) {
250# else
251 if (!record->event.pressed) {
252# endif
253# if defined(RGBLIGHT_ENABLE) && !defined(RGBLIGHT_DISABLE_KEYCODES)
254 rgblight_increase_sat();
255# endif
256# if defined(RGB_MATRIX_ENABLE) && !defined(RGB_MATRIX_DISABLE_KEYCODES)
257 rgb_matrix_increase_sat();
258# endif
259 }
260 } else if (keycode == RGB_SAD) {
261# ifndef SPLIT_KEYBOARD
262 if (record->event.pressed) {
263# else
264 if (!record->event.pressed) {
265# endif
266# if defined(RGBLIGHT_ENABLE) && !defined(RGBLIGHT_DISABLE_KEYCODES)
267 rgblight_decrease_sat();
268# endif
269# if defined(RGB_MATRIX_ENABLE) && !defined(RGB_MATRIX_DISABLE_KEYCODES)
270 rgb_matrix_decrease_sat();
271# endif
272 }
273 } else if (keycode == RGB_VAI) {
274# ifndef SPLIT_KEYBOARD
275 if (record->event.pressed) {
276# else
277 if (!record->event.pressed) {
278# endif
279# if defined(RGBLIGHT_ENABLE) && !defined(RGBLIGHT_DISABLE_KEYCODES)
280 rgblight_increase_val();
281# endif
282# if defined(RGB_MATRIX_ENABLE) && !defined(RGB_MATRIX_DISABLE_KEYCODES)
283 rgb_matrix_increase_val();
284# endif
285 }
286 } else if (keycode == RGB_VAD) {
287# ifndef SPLIT_KEYBOARD
288 if (record->event.pressed) {
289# else
290 if (!record->event.pressed) {
291# endif
292# if defined(RGBLIGHT_ENABLE) && !defined(RGBLIGHT_DISABLE_KEYCODES)
293 rgblight_decrease_val();
294# endif
295# if defined(RGB_MATRIX_ENABLE) && !defined(RGB_MATRIX_DISABLE_KEYCODES)
296 rgb_matrix_decrease_val();
297# endif
298 }
299 } else if (keycode == RGB_SPI) {
300 if (record->event.pressed) {
301# if defined(RGBLIGHT_ENABLE) && !defined(RGBLIGHT_DISABLE_KEYCODES)
302 rgblight_increase_speed();
303# endif
304# if defined(RGB_MATRIX_ENABLE) && !defined(RGB_MATRIX_DISABLE_KEYCODES)
305 rgb_matrix_increase_speed();
306# endif
307 }
308 } else if (keycode == RGB_SPD) {
309 if (record->event.pressed) {
310# if defined(RGBLIGHT_ENABLE) && !defined(RGBLIGHT_DISABLE_KEYCODES)
311 rgblight_decrease_speed();
312# endif
313# if defined(RGB_MATRIX_ENABLE) && !defined(RGB_MATRIX_DISABLE_KEYCODES)
314 rgb_matrix_decrease_speed();
315# endif
316 }
317 }
318 return false;
319# endif
320#endif
321 }
322 }
323 return true;
117} 324}
diff --git a/users/drashna/process_records.h b/users/drashna/process_records.h
index cb7ec3ec4..999882d4b 100644
--- a/users/drashna/process_records.h
+++ b/users/drashna/process_records.h
@@ -34,13 +34,13 @@ enum userspace_custom_keycodes {
34bool process_record_secrets(uint16_t keycode, keyrecord_t *record); 34bool process_record_secrets(uint16_t keycode, keyrecord_t *record);
35bool process_record_keymap(uint16_t keycode, keyrecord_t *record); 35bool process_record_keymap(uint16_t keycode, keyrecord_t *record);
36 36
37#define LOWER MO(_LOWER) 37#define LOWER MO(_LOWER)
38#define RAISE MO(_RAISE) 38#define RAISE MO(_RAISE)
39#define ADJUST MO(_ADJUST) 39#define ADJUST MO(_ADJUST)
40#define TG_MODS TG(_MODS) 40#define TG_MODS TG(_MODS)
41#define TG_GAME TG(_GAMEPAD) 41#define TG_GAME TG(_GAMEPAD)
42#define OS_LWR OSL(_LOWER) 42#define OS_LWR OSL(_LOWER)
43#define OS_RSE OSL(_RAISE) 43#define OS_RSE OSL(_RAISE)
44 44
45#define KC_SEC1 KC_SECRET_1 45#define KC_SEC1 KC_SECRET_1
46#define KC_SEC2 KC_SECRET_2 46#define KC_SEC2 KC_SECRET_2
@@ -48,13 +48,13 @@ bool process_record_keymap(uint16_t keycode, keyrecord_t *record);
48#define KC_SEC4 KC_SECRET_4 48#define KC_SEC4 KC_SECRET_4
49#define KC_SEC5 KC_SECRET_5 49#define KC_SEC5 KC_SECRET_5
50 50
51#define QWERTY KC_QWERTY 51#define QWERTY KC_QWERTY
52#define DVORAK KC_DVORAK 52#define DVORAK KC_DVORAK
53#define COLEMAK KC_COLEMAK 53#define COLEMAK KC_COLEMAK
54#define WORKMAN KC_WORKMAN 54#define WORKMAN KC_WORKMAN
55 55
56#define KC_RESET RESET 56#define KC_RESET RESET
57#define KC_RST KC_RESET 57#define KC_RST KC_RESET
58 58
59#ifdef SWAP_HANDS_ENABLE 59#ifdef SWAP_HANDS_ENABLE
60# define KC_C1R3 SH_T(KC_TAB) 60# define KC_C1R3 SH_T(KC_TAB)
@@ -81,7 +81,7 @@ bool process_record_keymap(uint16_t keycode, keyrecord_t *record);
81#define OS_RCTL OSM(MOD_RCTL) 81#define OS_RCTL OSM(MOD_RCTL)
82#define OS_LALT OSM(MOD_LALT) 82#define OS_LALT OSM(MOD_LALT)
83#define OS_RALT OSM(MOD_RALT) 83#define OS_RALT OSM(MOD_RALT)
84#define OS_MEH OSM(MOD_MEH) 84#define OS_MEH OSM(MOD_MEH)
85#define OS_HYPR OSM(MOD_HYPR) 85#define OS_HYPR OSM(MOD_HYPR)
86 86
87#define ALT_APP ALT_T(KC_APP) 87#define ALT_APP ALT_T(KC_APP)
diff --git a/users/drashna/rgb_matrix_stuff.c b/users/drashna/rgb_matrix_stuff.c
new file mode 100644
index 000000000..0914aab14
--- /dev/null
+++ b/users/drashna/rgb_matrix_stuff.c
@@ -0,0 +1,86 @@
1#include "drashna.h"
2
3#include "lib/lib8tion/lib8tion.h"
4extern led_config_t g_led_config;
5
6static uint32_t hypno_timer;
7#if defined(SPLIT_KEYBOARD) || defined(KEYBOARD_ergodox_ez) || defined(KEYBOARD_crkbd)
8# define RGB_MATRIX_REST_MODE RGB_MATRIX_CYCLE_OUT_IN_DUAL
9#else
10# define RGB_MATRIX_REST_MODE RGB_MATRIX_CYCLE_OUT_IN
11#endif
12
13void rgb_matrix_layer_helper(uint8_t hue, uint8_t sat, uint8_t val, uint8_t mode, uint8_t speed, uint8_t led_type) {
14 HSV hsv = {hue, sat, val};
15 if (hsv.v > rgb_matrix_config.hsv.v) {
16 hsv.v = rgb_matrix_config.hsv.v;
17 }
18
19 switch (mode) {
20 case 1: // breathing
21 {
22 uint16_t time = scale16by8(g_rgb_counters.tick, speed / 8);
23 hsv.v = scale8(abs8(sin8(time) - 128) * 2, hsv.v);
24 RGB rgb = hsv_to_rgb(hsv);
25 for (uint8_t i = 0; i < DRIVER_LED_TOTAL; i++) {
26 if (HAS_FLAGS(g_led_config.flags[i], led_type)) {
27 rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b);
28 }
29 }
30 break;
31 }
32 default: // Solid Color
33 {
34 RGB rgb = hsv_to_rgb(hsv);
35 for (uint8_t i = 0; i < DRIVER_LED_TOTAL; i++) {
36 if (HAS_FLAGS(g_led_config.flags[i], led_type)) {
37 rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b);
38 }
39 }
40 break;
41 }
42 }
43}
44
45__attribute__((weak)) void rgb_matrix_indicator_keymap(void) {}
46
47void matrix_scan_rgb_matrix(void) {
48#if defined(RGB_MATRIX_FRAMEBUFFER_EFFECTS)
49 if (userspace_config.rgb_matrix_idle_anim && rgb_matrix_get_mode() == RGB_MATRIX_TYPING_HEATMAP && timer_elapsed32(hypno_timer) > 15000) {
50 rgb_matrix_mode_noeeprom(RGB_MATRIX_REST_MODE);
51 }
52#endif
53 rgb_matrix_indicator_keymap();
54}
55
56void keyboard_post_init_rgb_matrix(void) {
57#if defined(RGB_MATRIX_FRAMEBUFFER_EFFECTS)
58 if (userspace_config.rgb_matrix_idle_anim) {
59 rgb_matrix_mode_noeeprom(RGB_MATRIX_REST_MODE);
60 }
61#endif
62}
63
64bool process_record_user_rgb_matrix(uint16_t keycode, keyrecord_t *record) {
65#if defined(RGB_MATRIX_FRAMEBUFFER_EFFECTS)
66 hypno_timer = timer_read32();
67 if (userspace_config.rgb_matrix_idle_anim && rgb_matrix_get_mode() == RGB_MATRIX_REST_MODE) {
68 rgb_matrix_mode_noeeprom(RGB_MATRIX_TYPING_HEATMAP);
69 }
70#endif
71 switch (keycode) {
72 case RGB_IDL: // This allows me to use underglow as layer indication, or as normal
73#if defined(RGB_MATRIX_ENABLE) && defined(RGB_MATRIX_FRAMEBUFFER_EFFECTS)
74 if (record->event.pressed) {
75 userspace_config.rgb_matrix_idle_anim ^= 1;
76 dprintf("RGB Matrix Idle Animation [EEPROM]: %u\n", userspace_config.rgb_matrix_idle_anim);
77 eeconfig_update_user(userspace_config.raw);
78 if (userspace_config.rgb_matrix_idle_anim) {
79 rgb_matrix_mode_noeeprom(RGB_MATRIX_TYPING_HEATMAP);
80 }
81 }
82#endif
83 break;
84 }
85 return true;
86}
diff --git a/users/drashna/rgb_matrix_stuff.h b/users/drashna/rgb_matrix_stuff.h
new file mode 100644
index 000000000..35b01047b
--- /dev/null
+++ b/users/drashna/rgb_matrix_stuff.h
@@ -0,0 +1,9 @@
1#pragma once
2#include "quantum.h"
3
4bool process_record_user_rgb_matrix(uint16_t keycode, keyrecord_t *record);
5void keyboard_post_init_rgb_matrix(void);
6void matrix_scan_rgb_matrix(void);
7
8void rgb_matrix_set_color_all(uint8_t red, uint8_t green, uint8_t blue);
9void rgb_matrix_layer_helper(uint8_t hue, uint8_t sat, uint8_t val, uint8_t mode, uint8_t speed, uint8_t led_type);
diff --git a/users/drashna/rgb_stuff.c b/users/drashna/rgb_stuff.c
index e7247f754..06b1e3c0c 100644
--- a/users/drashna/rgb_stuff.c
+++ b/users/drashna/rgb_stuff.c
@@ -2,89 +2,77 @@
2#include "rgb_stuff.h" 2#include "rgb_stuff.h"
3#include "eeprom.h" 3#include "eeprom.h"
4 4
5#if defined(RGBLIGHT_ENABLE)
6extern rgblight_config_t rgblight_config; 5extern rgblight_config_t rgblight_config;
7bool has_initialized; 6bool has_initialized;
8 7
9void rgblight_sethsv_default_helper(uint8_t index) { rgblight_sethsv_at(rgblight_config.hue, rgblight_config.sat, rgblight_config.val, index); } 8void rgblight_sethsv_default_helper(uint8_t index) { rgblight_sethsv_at(rgblight_config.hue, rgblight_config.sat, rgblight_config.val, index); }
10#endif // RGBLIGHT_ENABLE
11
12#if defined(RGB_MATRIX_ENABLE)
13static uint32_t hypno_timer;
14# if defined(SPLIT_KEYBOARD) || defined(KEYBOARD_ergodox_ez) || defined(KEYBOARD_crkbd)
15# define RGB_MATRIX_REST_MODE RGB_MATRIX_CYCLE_OUT_IN_DUAL
16# else
17# define RGB_MATRIX_REST_MODE RGB_MATRIX_CYCLE_OUT_IN
18# endif
19#endif
20 9
21/* Custom indicators for modifiers. 10/* Custom indicators for modifiers.
22 * This allows for certain lights to be lit up, based on what mods are active, giving some visual feedback. 11 * This allows for certain lights to be lit up, based on what mods are active, giving some visual feedback.
23 * This is especially useful for One Shot Mods, since it's not always obvious if they're still lit up. 12 * This is especially useful for One Shot Mods, since it's not always obvious if they're still lit up.
24 */ 13 */
25#ifdef RGBLIGHT_ENABLE 14#ifdef INDICATOR_LIGHTS
26# ifdef INDICATOR_LIGHTS
27void set_rgb_indicators(uint8_t this_mod, uint8_t this_led, uint8_t this_osm) { 15void set_rgb_indicators(uint8_t this_mod, uint8_t this_led, uint8_t this_osm) {
28 if (userspace_config.rgb_layer_change && get_highest_layer(layer_state) == 0) { 16 if (userspace_config.rgb_layer_change && get_highest_layer(layer_state) == 0) {
29 if ((this_mod | this_osm) & MOD_MASK_SHIFT || this_led & (1 << USB_LED_CAPS_LOCK)) { 17 if ((this_mod | this_osm) & MOD_MASK_SHIFT || this_led & (1 << USB_LED_CAPS_LOCK)) {
30# ifdef SHFT_LED1 18# ifdef SHFT_LED1
31 rgblight_sethsv_at(120, 255, 255, SHFT_LED1); 19 rgblight_sethsv_at(120, 255, 255, SHFT_LED1);
32# endif // SHFT_LED1 20# endif // SHFT_LED1
33# ifdef SHFT_LED2 21# ifdef SHFT_LED2
34 rgblight_sethsv_at(120, 255, 255, SHFT_LED2); 22 rgblight_sethsv_at(120, 255, 255, SHFT_LED2);
35# endif // SHFT_LED2 23# endif // SHFT_LED2
36 } else { 24 } else {
37# ifdef SHFT_LED1 25# ifdef SHFT_LED1
38 rgblight_sethsv_default_helper(SHFT_LED1); 26 rgblight_sethsv_default_helper(SHFT_LED1);
39# endif // SHFT_LED1 27# endif // SHFT_LED1
40# ifdef SHFT_LED2 28# ifdef SHFT_LED2
41 rgblight_sethsv_default_helper(SHFT_LED2); 29 rgblight_sethsv_default_helper(SHFT_LED2);
42# endif // SHFT_LED2 30# endif // SHFT_LED2
43 } 31 }
44 if ((this_mod | this_osm) & MOD_MASK_CTRL) { 32 if ((this_mod | this_osm) & MOD_MASK_CTRL) {
45# ifdef CTRL_LED1 33# ifdef CTRL_LED1
46 rgblight_sethsv_at(0, 255, 255, CTRL_LED1); 34 rgblight_sethsv_at(0, 255, 255, CTRL_LED1);
47# endif // CTRL_LED1 35# endif // CTRL_LED1
48# ifdef CTRL_LED2 36# ifdef CTRL_LED2
49 rgblight_sethsv_at(0, 255, 255, CTRL_LED2); 37 rgblight_sethsv_at(0, 255, 255, CTRL_LED2);
50# endif // CTRL_LED2 38# endif // CTRL_LED2
51 } else { 39 } else {
52# ifdef CTRL_LED1 40# ifdef CTRL_LED1
53 rgblight_sethsv_default_helper(CTRL_LED1); 41 rgblight_sethsv_default_helper(CTRL_LED1);
54# endif // CTRL_LED1 42# endif // CTRL_LED1
55# ifdef CTRL_LED2 43# ifdef CTRL_LED2
56 rgblight_sethsv_default_helper(CTRL_LED2); 44 rgblight_sethsv_default_helper(CTRL_LED2);
57# endif // CTRL_LED2 45# endif // CTRL_LED2
58 } 46 }
59 if ((this_mod | this_osm) & MOD_MASK_GUI) { 47 if ((this_mod | this_osm) & MOD_MASK_GUI) {
60# ifdef GUI_LED1 48# ifdef GUI_LED1
61 rgblight_sethsv_at(51, 255, 255, GUI_LED1); 49 rgblight_sethsv_at(51, 255, 255, GUI_LED1);
62# endif // GUI_LED1 50# endif // GUI_LED1
63# ifdef GUI_LED2 51# ifdef GUI_LED2
64 rgblight_sethsv_at(51, 255, 255, GUI_LED2); 52 rgblight_sethsv_at(51, 255, 255, GUI_LED2);
65# endif // GUI_LED2 53# endif // GUI_LED2
66 } else { 54 } else {
67# ifdef GUI_LED1 55# ifdef GUI_LED1
68 rgblight_sethsv_default_helper(GUI_LED1); 56 rgblight_sethsv_default_helper(GUI_LED1);
69# endif // GUI_LED1 57# endif // GUI_LED1
70# ifdef GUI_LED2 58# ifdef GUI_LED2
71 rgblight_sethsv_default_helper(GUI_LED2); 59 rgblight_sethsv_default_helper(GUI_LED2);
72# endif // GUI_LED2 60# endif // GUI_LED2
73 } 61 }
74 if ((this_mod | this_osm) & MOD_MASK_ALT) { 62 if ((this_mod | this_osm) & MOD_MASK_ALT) {
75# ifdef ALT_LED1 63# ifdef ALT_LED1
76 rgblight_sethsv_at(240, 255, 255, ALT_LED1); 64 rgblight_sethsv_at(240, 255, 255, ALT_LED1);
77# endif // ALT_LED1 65# endif // ALT_LED1
78# ifdef GUI_LED2 66# ifdef GUI_LED2
79 rgblight_sethsv_at(240, 255, 255, ALT_LED2); 67 rgblight_sethsv_at(240, 255, 255, ALT_LED2);
80# endif // GUI_LED2 68# endif // GUI_LED2
81 } else { 69 } else {
82# ifdef GUI_LED1 70# ifdef GUI_LED1
83 rgblight_sethsv_default_helper(ALT_LED1); 71 rgblight_sethsv_default_helper(ALT_LED1);
84# endif // GUI_LED1 72# endif // GUI_LED1
85# ifdef GUI_LED2 73# ifdef GUI_LED2
86 rgblight_sethsv_default_helper(ALT_LED2); 74 rgblight_sethsv_default_helper(ALT_LED2);
87# endif // GUI_LED2 75# endif // GUI_LED2
88 } 76 }
89 } 77 }
90} 78}
@@ -95,9 +83,9 @@ void matrix_scan_indicator(void) {
95 set_rgb_indicators(get_mods(), host_keyboard_leds(), get_oneshot_mods()); 83 set_rgb_indicators(get_mods(), host_keyboard_leds(), get_oneshot_mods());
96 } 84 }
97} 85}
98# endif // INDICATOR_LIGHTS 86#endif // INDICATOR_LIGHTS
99 87
100# ifdef RGBLIGHT_TWINKLE 88#ifdef RGBLIGHT_TWINKLE
101static rgblight_fadeout lights[RGBLED_NUM]; 89static rgblight_fadeout lights[RGBLED_NUM];
102 90
103__attribute__((weak)) bool rgblight_twinkle_is_led_used_keymap(uint8_t index) { return false; } 91__attribute__((weak)) bool rgblight_twinkle_is_led_used_keymap(uint8_t index) { return false; }
@@ -105,40 +93,40 @@ __attribute__((weak)) bool rgblight_twinkle_is_led_used_keymap(uint8_t index) {
105/* This function checks for used LEDs. This way, collisions don't occur and cause weird rendering */ 93/* This function checks for used LEDs. This way, collisions don't occur and cause weird rendering */
106bool rgblight_twinkle_is_led_used(uint8_t index) { 94bool rgblight_twinkle_is_led_used(uint8_t index) {
107 switch (index) { 95 switch (index) {
108# ifdef INDICATOR_LIGHTS 96# ifdef INDICATOR_LIGHTS
109# ifdef SHFT_LED1 97# ifdef SHFT_LED1
110 case SHFT_LED1: 98 case SHFT_LED1:
111 return true; 99 return true;
112# endif // SHFT_LED1 100# endif // SHFT_LED1
113# ifdef SHFT_LED2 101# ifdef SHFT_LED2
114 case SHFT_LED2: 102 case SHFT_LED2:
115 return true; 103 return true;
116# endif // SHFT_LED2 104# endif // SHFT_LED2
117# ifdef CTRL_LED1 105# ifdef CTRL_LED1
118 case CTRL_LED1: 106 case CTRL_LED1:
119 return true; 107 return true;
120# endif // CTRL_LED1 108# endif // CTRL_LED1
121# ifdef CTRL_LED2 109# ifdef CTRL_LED2
122 case CTRL_LED2: 110 case CTRL_LED2:
123 return true; 111 return true;
124# endif // CTRL_LED2 112# endif // CTRL_LED2
125# ifdef GUI_LED1 113# ifdef GUI_LED1
126 case GUI_LED1: 114 case GUI_LED1:
127 return true; 115 return true;
128# endif // GUI_LED1 116# endif // GUI_LED1
129# ifdef GUI_LED2 117# ifdef GUI_LED2
130 case GUI_LED2: 118 case GUI_LED2:
131 return true; 119 return true;
132# endif // GUI_LED2 120# endif // GUI_LED2
133# ifdef ALT_LED1 121# ifdef ALT_LED1
134 case ALT_LED1: 122 case ALT_LED1:
135 return true; 123 return true;
136# endif // ALT_LED1 124# endif // ALT_LED1
137# ifdef ALT_LED2 125# ifdef ALT_LED2
138 case ALT_LED2: 126 case ALT_LED2:
139 return true; 127 return true;
140# endif // ALT_LED2 128# endif // ALT_LED2
141# endif // INDICATOR_LIGHTS 129# endif // INDICATOR_LIGHTS
142 default: 130 default:
143 return rgblight_twinkle_is_led_used_keymap(index); 131 return rgblight_twinkle_is_led_used_keymap(index);
144 } 132 }
@@ -213,23 +201,15 @@ void start_rgb_light(void) {
213 201
214 rgblight_sethsv_at(light->hue, 255, light->life, light_index); 202 rgblight_sethsv_at(light->hue, 255, light->life, light_index);
215} 203}
216# endif 204#endif
217#endif // RGBLIGHT_ENABLE
218 205
219bool process_record_user_rgb(uint16_t keycode, keyrecord_t *record) { 206bool process_record_user_rgb_light(uint16_t keycode, keyrecord_t *record) {
220 uint16_t temp_keycode = keycode; 207 uint16_t temp_keycode = keycode;
221 // Filter out the actual keycode from MT and LT keys. 208 // Filter out the actual keycode from MT and LT keys.
222 if ((keycode >= QK_MOD_TAP && keycode <= QK_MOD_TAP_MAX) || (keycode >= QK_LAYER_TAP && keycode <= QK_LAYER_TAP_MAX)) { 209 if ((keycode >= QK_MOD_TAP && keycode <= QK_MOD_TAP_MAX) || (keycode >= QK_LAYER_TAP && keycode <= QK_LAYER_TAP_MAX)) {
223 temp_keycode &= 0xFF; 210 temp_keycode &= 0xFF;
224 } 211 }
225 212
226#if defined(RGB_MATRIX_ENABLE) && defined(RGB_MATRIX_FRAMEBUFFER_EFFECTS)
227 hypno_timer = timer_read32();
228 if (userspace_config.rgb_matrix_idle_anim && rgb_matrix_get_mode() == RGB_MATRIX_REST_MODE) {
229 rgb_matrix_mode_noeeprom(RGB_MATRIX_TYPING_HEATMAP);
230 }
231#endif
232
233 switch (temp_keycode) { 213 switch (temp_keycode) {
234#ifdef RGBLIGHT_TWINKLE 214#ifdef RGBLIGHT_TWINKLE
235 case KC_A ... KC_SLASH: 215 case KC_A ... KC_SLASH:
@@ -242,228 +222,19 @@ bool process_record_user_rgb(uint16_t keycode, keyrecord_t *record) {
242 start_rgb_light(); 222 start_rgb_light();
243 } 223 }
244 break; 224 break;
245#endif // RGBLIGHT_TWINKLE 225#endif // RGBLIGHT_TWINKLE
246 case KC_RGB_T: // This allows me to use underglow as layer indication, or as normal
247#if defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE)
248 if (record->event.pressed) {
249 userspace_config.rgb_layer_change ^= 1;
250 dprintf("rgblight layer change [EEPROM]: %u\n", userspace_config.rgb_layer_change);
251 eeconfig_update_user(userspace_config.raw);
252 if (userspace_config.rgb_layer_change) {
253# if defined(RGBLIGHT_ENABLE) && defined(RGB_MATRIX_ENABLE)
254 rgblight_enable_noeeprom();
255# endif
256 layer_state_set(layer_state); // This is needed to immediately set the layer color (looks better)
257# if defined(RGBLIGHT_ENABLE) && defined(RGB_MATRIX_ENABLE)
258 } else {
259 rgblight_disable_noeeprom();
260# endif
261 }
262 }
263#endif // RGBLIGHT_ENABLE
264 break;
265 case RGB_IDL: // This allows me to use underglow as layer indication, or as normal
266#if defined(RGB_MATRIX_ENABLE) && defined(RGB_MATRIX_FRAMEBUFFER_EFFECTS)
267 if (record->event.pressed) {
268 userspace_config.rgb_matrix_idle_anim ^= 1;
269 dprintf("RGB Matrix Idle Animation [EEPROM]: %u\n", userspace_config.rgb_matrix_idle_anim);
270 eeconfig_update_user(userspace_config.raw);
271 if (userspace_config.rgb_matrix_idle_anim) {
272 rgb_matrix_mode_noeeprom(RGB_MATRIX_TYPING_HEATMAP);
273 }
274 }
275#endif
276 break;
277#if defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE)
278 case RGB_TOG:
279 // Split keyboards need to trigger on key-up for edge-case issue
280# ifndef SPLIT_KEYBOARD
281 if (record->event.pressed) {
282# else
283 if (!record->event.pressed) {
284# endif
285# if defined(RGBLIGHT_ENABLE) && !defined(RGBLIGHT_DISABLE_KEYCODES)
286 rgblight_toggle();
287# endif
288# if defined(RGB_MATRIX_ENABLE) && !defined(RGB_MATRIX_DISABLE_KEYCODES)
289 rgb_matrix_toggle();
290# endif
291 }
292 return false;
293 break;
294 case RGB_MODE_FORWARD ... RGB_MODE_GRADIENT: // quantum_keycodes.h L400 for definitions
295 if (record->event.pressed) {
296 bool is_eeprom_updated;
297# if defined(RGBLIGHT_ENABLE) && !defined(RGBLIGHT_DISABLE_KEYCODES)
298 // This disables layer indication, as it's assumed that if you're changing this ... you want that disabled
299 if (userspace_config.rgb_layer_change) {
300 userspace_config.rgb_layer_change = false;
301 dprintf("rgblight layer change [EEPROM]: %u\n", userspace_config.rgb_layer_change);
302 is_eeprom_updated = true;
303 }
304# endif
305# if defined(RGB_MATRIX_ENABLE) && defined(RGB_MATRIX_FRAMEBUFFER_EFFECTS)
306 if (userspace_config.rgb_matrix_idle_anim) {
307 userspace_config.rgb_matrix_idle_anim = false;
308 dprintf("RGB Matrix Idle Animation [EEPROM]: %u\n", userspace_config.rgb_matrix_idle_anim);
309 is_eeprom_updated = true;
310 }
311# endif
312 if (is_eeprom_updated) {
313 eeconfig_update_user(userspace_config.raw);
314 }
315 }
316
317# if defined(RGBLIGHT_DISABLE_KEYCODES) || defined(RGB_MATRIX_DISABLE_KEYCODES)
318 if (keycode == RGB_MODE_FORWARD && record->event.pressed) {
319 uint8_t shifted = get_mods() & (MOD_MASK_SHIFT);
320 if (shifted) {
321# if defined(RGBLIGHT_ENABLE) && !defined(RGBLIGHT_DISABLE_KEYCODES)
322 rgblight_step_reverse();
323# endif
324# if defined(RGB_MATRIX_ENABLE) && !defined(RGB_MATRIX_DISABLE_KEYCODES)
325 rgb_matrix_step_reverse();
326# endif
327 } else {
328# if defined(RGBLIGHT_ENABLE) && !defined(RGBLIGHT_DISABLE_KEYCODES)
329 rgblight_step();
330# endif
331# if defined(RGB_MATRIX_ENABLE) && !defined(RGB_MATRIX_DISABLE_KEYCODES)
332 rgb_matrix_step();
333# endif
334 }
335 } else if (keycode == RGB_MODE_REVERSE && record->event.pressed) {
336 uint8_t shifted = get_mods() & (MOD_MASK_SHIFT);
337 if (shifted) {
338# if defined(RGBLIGHT_ENABLE) && !defined(RGBLIGHT_DISABLE_KEYCODES)
339 rgblight_step();
340# endif
341# if defined(RGB_MATRIX_ENABLE) && !defined(RGB_MATRIX_DISABLE_KEYCODES)
342 rgb_matrix_step();
343# endif
344 } else {
345# if defined(RGBLIGHT_ENABLE) && !defined(RGBLIGHT_DISABLE_KEYCODES)
346 rgblight_step_reverse();
347# endif
348# if defined(RGB_MATRIX_ENABLE) && !defined(RGB_MATRIX_DISABLE_KEYCODES)
349 rgb_matrix_step_reverse();
350# endif
351 }
352 } else if (keycode == RGB_HUI) {
353# ifndef SPLIT_KEYBOARD
354 if (record->event.pressed) {
355# else
356 if (!record->event.pressed) {
357# endif
358# if defined(RGBLIGHT_ENABLE) && !defined(RGBLIGHT_DISABLE_KEYCODES)
359 rgblight_increase_hue();
360# endif
361# if defined(RGB_MATRIX_ENABLE) && !defined(RGB_MATRIX_DISABLE_KEYCODES)
362 rgb_matrix_increase_hue();
363# endif
364 }
365 } else if (keycode == RGB_HUD) {
366# ifndef SPLIT_KEYBOARD
367 if (record->event.pressed) {
368# else
369 if (!record->event.pressed) {
370# endif
371# if defined(RGBLIGHT_ENABLE) && !defined(RGBLIGHT_DISABLE_KEYCODES)
372 rgblight_decrease_hue();
373# endif
374# if defined(RGB_MATRIX_ENABLE) && !defined(RGB_MATRIX_DISABLE_KEYCODES)
375 rgb_matrix_decrease_hue();
376# endif
377 }
378 } else if (keycode == RGB_SAI) {
379# ifndef SPLIT_KEYBOARD
380 if (record->event.pressed) {
381# else
382 if (!record->event.pressed) {
383# endif
384# if defined(RGBLIGHT_ENABLE) && !defined(RGBLIGHT_DISABLE_KEYCODES)
385 rgblight_increase_sat();
386# endif
387# if defined(RGB_MATRIX_ENABLE) && !defined(RGB_MATRIX_DISABLE_KEYCODES)
388 rgb_matrix_increase_sat();
389# endif
390 }
391 } else if (keycode == RGB_SAD) {
392# ifndef SPLIT_KEYBOARD
393 if (record->event.pressed) {
394# else
395 if (!record->event.pressed) {
396# endif
397# if defined(RGBLIGHT_ENABLE) && !defined(RGBLIGHT_DISABLE_KEYCODES)
398 rgblight_decrease_sat();
399# endif
400# if defined(RGB_MATRIX_ENABLE) && !defined(RGB_MATRIX_DISABLE_KEYCODES)
401 rgb_matrix_decrease_sat();
402# endif
403 }
404 } else if (keycode == RGB_VAI) {
405# ifndef SPLIT_KEYBOARD
406 if (record->event.pressed) {
407# else
408 if (!record->event.pressed) {
409# endif
410# if defined(RGBLIGHT_ENABLE) && !defined(RGBLIGHT_DISABLE_KEYCODES)
411 rgblight_increase_val();
412# endif
413# if defined(RGB_MATRIX_ENABLE) && !defined(RGB_MATRIX_DISABLE_KEYCODES)
414 rgb_matrix_increase_val();
415# endif
416 }
417 } else if (keycode == RGB_VAD) {
418# ifndef SPLIT_KEYBOARD
419 if (record->event.pressed) {
420# else
421 if (!record->event.pressed) {
422# endif
423# if defined(RGBLIGHT_ENABLE) && !defined(RGBLIGHT_DISABLE_KEYCODES)
424 rgblight_decrease_val();
425# endif
426# if defined(RGB_MATRIX_ENABLE) && !defined(RGB_MATRIX_DISABLE_KEYCODES)
427 rgb_matrix_decrease_val();
428# endif
429 }
430 } else if (keycode == RGB_SPI) {
431 if (record->event.pressed) {
432# if defined(RGBLIGHT_ENABLE) && !defined(RGBLIGHT_DISABLE_KEYCODES)
433 rgblight_increase_speed();
434# endif
435# if defined(RGB_MATRIX_ENABLE) && !defined(RGB_MATRIX_DISABLE_KEYCODES)
436 rgb_matrix_increase_speed();
437# endif
438 }
439 } else if (keycode == RGB_SPD) {
440 if (record->event.pressed) {
441# if defined(RGBLIGHT_ENABLE) && !defined(RGBLIGHT_DISABLE_KEYCODES)
442 rgblight_decrease_speed();
443# endif
444# if defined(RGB_MATRIX_ENABLE) && !defined(RGB_MATRIX_DISABLE_KEYCODES)
445 rgb_matrix_decrease_speed();
446# endif
447 }
448 }
449 return false;
450# endif
451#endif
452
453 break;
454 } 226 }
455 return true; 227 return true;
456} 228}
457 229
458void keyboard_post_init_rgb(void) { 230void keyboard_post_init_rgb_light(void) {
459#if defined(RGBLIGHT_ENABLE) 231#if defined(RGBLIGHT_STARTUP_ANIMATION)
460# if defined(RGBLIGHT_STARTUP_ANIMATION)
461 bool is_enabled = rgblight_config.enable; 232 bool is_enabled = rgblight_config.enable;
462 if (userspace_config.rgb_layer_change) { 233 if (userspace_config.rgb_layer_change) {
463 rgblight_enable_noeeprom(); 234 rgblight_enable_noeeprom();
464 } 235 }
465 if (rgblight_config.enable) { 236 if (rgblight_config.enable) {
466 layer_state_set_user(layer_state); 237 layer_state_set_rgb_light(layer_state);
467 uint16_t old_hue = rgblight_config.hue; 238 uint16_t old_hue = rgblight_config.hue;
468 rgblight_mode_noeeprom(RGBLIGHT_MODE_STATIC_LIGHT); 239 rgblight_mode_noeeprom(RGBLIGHT_MODE_STATIC_LIGHT);
469 for (uint16_t i = 255; i > 0; i--) { 240 for (uint16_t i = 255; i > 0; i--) {
@@ -476,17 +247,11 @@ void keyboard_post_init_rgb(void) {
476 rgblight_disable_noeeprom(); 247 rgblight_disable_noeeprom();
477 } 248 }
478 249
479# endif
480 layer_state_set_user(layer_state);
481#endif
482#if defined(RGB_MATRIX_ENABLE) && defined(RGB_MATRIX_FRAMEBUFFER_EFFECTS)
483 if (userspace_config.rgb_matrix_idle_anim) {
484 rgb_matrix_mode_noeeprom(RGB_MATRIX_REST_MODE);
485 }
486#endif 250#endif
251 layer_state_set_rgb_light(layer_state);
487} 252}
488 253
489void matrix_scan_rgb(void) { 254void matrix_scan_rgb_light(void) {
490#ifdef RGBLIGHT_ENABLE 255#ifdef RGBLIGHT_ENABLE
491# ifdef RGBLIGHT_TWINKLE 256# ifdef RGBLIGHT_TWINKLE
492 scan_rgblight_fadeout(); 257 scan_rgblight_fadeout();
@@ -496,23 +261,15 @@ void matrix_scan_rgb(void) {
496 matrix_scan_indicator(); 261 matrix_scan_indicator();
497# endif 262# endif
498#endif 263#endif
499
500#if defined(RGB_MATRIX_ENABLE) && defined(RGB_MATRIX_FRAMEBUFFER_EFFECTS)
501 if (userspace_config.rgb_matrix_idle_anim && rgb_matrix_get_mode() == RGB_MATRIX_TYPING_HEATMAP && timer_elapsed32(hypno_timer) > 15000) {
502 rgb_matrix_mode_noeeprom(RGB_MATRIX_REST_MODE);
503 }
504#endif
505} 264}
506 265
507#ifdef RGBLIGHT_ENABLE
508void rgblight_set_hsv_and_mode(uint8_t hue, uint8_t sat, uint8_t val, uint8_t mode) { 266void rgblight_set_hsv_and_mode(uint8_t hue, uint8_t sat, uint8_t val, uint8_t mode) {
509 rgblight_sethsv_noeeprom(hue, sat, val); 267 rgblight_sethsv_noeeprom(hue, sat, val);
510 wait_us(175); // Add a slight delay between color and mode to ensure it's processed correctly 268 wait_us(175); // Add a slight delay between color and mode to ensure it's processed correctly
511 rgblight_mode_noeeprom(mode); 269 rgblight_mode_noeeprom(mode);
512} 270}
513#endif
514 271
515layer_state_t layer_state_set_rgb(layer_state_t state) { 272layer_state_t layer_state_set_rgb_light(layer_state_t state) {
516#ifdef RGBLIGHT_ENABLE 273#ifdef RGBLIGHT_ENABLE
517 if (userspace_config.rgb_layer_change) { 274 if (userspace_config.rgb_layer_change) {
518 switch (get_highest_layer(state)) { 275 switch (get_highest_layer(state)) {
@@ -574,40 +331,3 @@ layer_state_t layer_state_set_rgb(layer_state_t state) {
574 331
575 return state; 332 return state;
576} 333}
577
578#ifdef RGB_MATRIX_ENABLE
579# include "lib/lib8tion/lib8tion.h"
580extern led_config_t g_led_config;
581
582void rgb_matrix_layer_helper(uint8_t hue, uint8_t sat, uint8_t val, uint8_t mode, uint8_t speed, uint8_t led_type) {
583 HSV hsv = {hue, sat, val};
584 if (hsv.v > rgb_matrix_config.hsv.v) {
585 hsv.v = rgb_matrix_config.hsv.v;
586 }
587
588 switch (mode) {
589 case 1: // breathing
590 {
591 uint16_t time = scale16by8(g_rgb_counters.tick, speed / 8);
592 hsv.v = scale8(abs8(sin8(time) - 128) * 2, hsv.v);
593 RGB rgb = hsv_to_rgb(hsv);
594 for (uint8_t i = 0; i < DRIVER_LED_TOTAL; i++) {
595 if (HAS_FLAGS(g_led_config.flags[i], led_type)) {
596 rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b);
597 }
598 }
599 break;
600 }
601 default: // Solid Color
602 {
603 RGB rgb = hsv_to_rgb(hsv);
604 for (uint8_t i = 0; i < DRIVER_LED_TOTAL; i++) {
605 if (HAS_FLAGS(g_led_config.flags[i], led_type)) {
606 rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b);
607 }
608 }
609 break;
610 }
611 }
612}
613#endif
diff --git a/users/drashna/rgb_stuff.h b/users/drashna/rgb_stuff.h
index 50b73c1c3..98a552db1 100644
--- a/users/drashna/rgb_stuff.h
+++ b/users/drashna/rgb_stuff.h
@@ -1,10 +1,7 @@
1#pragma once 1#pragma once
2#include "quantum.h" 2#include "quantum.h"
3#ifdef RGB_MATRIX_ENABLE
4# include "rgb_matrix.h"
5#endif
6 3
7#if defined(RGBLIGHT_ENABLE) && defined(RGBLIGHT_TWINKLE) 4#if defined(RGBLIGHT_TWINKLE)
8typedef struct { 5typedef struct {
9 bool enabled; 6 bool enabled;
10 uint8_t hue; 7 uint8_t hue;
@@ -13,20 +10,13 @@ typedef struct {
13} rgblight_fadeout; 10} rgblight_fadeout;
14#endif 11#endif
15 12
16bool process_record_user_rgb(uint16_t keycode, keyrecord_t *record); 13bool process_record_user_rgb_light(uint16_t keycode, keyrecord_t *record);
17void keyboard_post_init_rgb(void); 14void keyboard_post_init_rgb_light(void);
18void matrix_scan_rgb(void); 15void matrix_scan_rgb_light(void);
19layer_state_t layer_state_set_rgb(layer_state_t state); 16layer_state_t layer_state_set_rgb_light(layer_state_t state);
20layer_state_t default_layer_state_set_rgb(layer_state_t state); 17layer_state_t default_layer_state_set_rgb_light(layer_state_t state);
18void rgblight_sethsv_default_helper(uint8_t index);
21 19
22#if defined(RGBLIGHT_ENABLE) && defined(RGBLIGHT_TWINKLE) 20#if defined(RGBLIGHT_TWINKLE)
23void scan_rgblight_fadeout(void); 21void scan_rgblight_fadeout(void);
24#endif 22#endif
25#if defined(RGBLIGHT_ENABLE)
26void rgblight_sethsv_default_helper(uint8_t index);
27#endif
28
29#ifdef RGB_MATRIX_ENABLE
30void rgb_matrix_set_color_all(uint8_t red, uint8_t green, uint8_t blue);
31void rgb_matrix_layer_helper(uint8_t hue, uint8_t sat, uint8_t val, uint8_t mode, uint8_t speed, uint8_t led_type);
32#endif
diff --git a/users/drashna/rules.mk b/users/drashna/rules.mk
index 4d55da803..051368ff5 100644
--- a/users/drashna/rules.mk
+++ b/users/drashna/rules.mk
@@ -2,9 +2,10 @@ SRC += drashna.c \
2 process_records.c 2 process_records.c
3 3
4ifneq ($(PLATFORM),CHIBIOS) 4ifneq ($(PLATFORM),CHIBIOS)
5 LTO_ENABLE = yes 5 LTO_ENABLE = yes
6endif 6endif
7SPACE_CADET_ENABLE = no 7SPACE_CADET_ENABLE = no
8GRAVE_ESC_ENABLE = no
8 9
9ifneq ($(strip $(NO_SECRETS)), yes) 10ifneq ($(strip $(NO_SECRETS)), yes)
10 ifneq ("$(wildcard $(USER_PATH)/secrets.c)","") 11 ifneq ("$(wildcard $(USER_PATH)/secrets.c)","")
@@ -19,10 +20,6 @@ ifeq ($(strip $(TAP_DANCE_ENABLE)), yes)
19 SRC += tap_dances.c 20 SRC += tap_dances.c
20endif 21endif
21 22
22
23
24
25
26ifeq ($(strip $(RGBLIGHT_ENABLE)), yes) 23ifeq ($(strip $(RGBLIGHT_ENABLE)), yes)
27 SRC += rgb_stuff.c 24 SRC += rgb_stuff.c
28 ifeq ($(strip $(INDICATOR_LIGHTS)), yes) 25 ifeq ($(strip $(INDICATOR_LIGHTS)), yes)
@@ -41,7 +38,7 @@ endif
41 38
42RGB_MATRIX_ENABLE ?= no 39RGB_MATRIX_ENABLE ?= no
43ifneq ($(strip $(RGB_MATRIX_ENABLE)), no) 40ifneq ($(strip $(RGB_MATRIX_ENABLE)), no)
44 SRC += rgb_stuff.c 41 SRC += rgb_matrix_stuff.c
45endif 42endif
46 43
47 44
@@ -61,3 +58,7 @@ endif
61ifeq ($(strip $(PROTOCOL)), VUSB) 58ifeq ($(strip $(PROTOCOL)), VUSB)
62 NKRO_ENABLE = no 59 NKRO_ENABLE = no
63endif 60endif
61
62ifeq ($(strip $(OLED_DRIVER_ENABLE)), yes)
63 SRC += oled_stuff.c
64endif
generated by cgit v1.2.3 (git 2.25.1) at 2025-11-22 11:41:12 +0000