gitbot/qmk_firmware
0
0
Fork 0
mirror of https://github.com/qmk/qmk_firmware.git synced 2024-11-22 03:19:24 +00:00
Code Issues Packages Projects Releases Wiki Activity

[Keymap] Cleanup and updating of drashna keymap code (#11516)

Browse Source 
* Update other keyboards for rgb matrix changes

* Remove customized bootmagic code

* Fix corne layout compilation error

* Fix compiler errors with all keymaps

* Add Simple Visualizer for ergodox infinity

* Fix compile issue with Corne

* Fix keymap stuff

* Add alias for mouse layer

* Add Halmak Keyboard layout

* Updates for Kyria

* Add support for oled interval

* Change RGB stuff

[CHANGE] Fix coexistence issues

* Fix rgb_stuff

* Add custom ploopyco mouse keymap

* Decrease default dwell time

* Updates based on last breaking changes update

* Disable command on dactyl

* Update ergodox to use proper commands for rgb matrix indicators

* Update all rgb matrix indicator functions

* Update rules for dactyl-manuform

* Reduce wait time for mouse layer off event

* Add more info to logger

* Add wrappers for get_tapping term

* Move version.h include into only file that actually needs it

* Update rgb sleep stuff

* Update key print function

* Change DM keymap settings

* Change pin for DM Manuform

* Add Proton C stuff for Corne keymap

* more arm corne tinkering

* Even more arm stuff for corne

* Cleanup corne stuff

* redirect default keymap to drashna

because I am a very bad man

* change corne rgb priority

* Update tractyl manuform to not conflict

* Add more secret stuff

* more dactyl tweaks

* Add more options to split transport

* Changes of oled support

* Change split settings

* Improve keylogger formatting more

* tweak oled stuff

* Oled and such tweaks

* Reduce brightness due to leds

* Decrease brightness more

* Only run layer code if master
This commit is contained in:
Drashna Jaelre 2021-01-22 08:23:03 -08:00 committed by GitHub
parent c16a3dcb54
commit 7a08b9d374
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
36 changed files with 588 additions and 270 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
keyboards/handwired/dactyl_manuform/5x6_right_trackball/5x6_right_trackball.c
View File

@ -142,7 +142,7 @@ void pointing_device_init(void) {
trackball_set_cpi(dpi_array[keyboard_config.dpi_config]); trackball_set_cpi(dpi_array[keyboard_config.dpi_config]);
} }
static bool has_mouse_report_changed(report_mouse_t new, report_mouse_t old) { static bool has_report_changed(report_mouse_t new, report_mouse_t old) {
return (new.buttons != old.buttons) || return (new.buttons != old.buttons) ||
(new.x && new.x != old.x) || (new.x && new.x != old.x) ||
(new.y && new.y != old.y) || (new.y && new.y != old.y) ||
@ -186,7 +186,7 @@ void pointing_device_send(void) {
mouseReport.x = 0; mouseReport.x = 0;
mouseReport.y = 0; mouseReport.y = 0;
process_mouse_user(&mouseReport, x, y); process_mouse_user(&mouseReport, x, y);
if (has_mouse_report_changed(mouseReport, old_report)) { if (has_report_changed(mouseReport, old_report)) {
host_mouse_send(&mouseReport); host_mouse_send(&mouseReport);
} }
} else { } else {

4
keyboards/handwired/dactyl_manuform/5x6_right_trackball/config.h
View File

@ -65,3 +65,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#define DYNAMIC_KEYMAP_EEPROM_MAX_ADDR 4095 #define DYNAMIC_KEYMAP_EEPROM_MAX_ADDR 4095
#define DYNAMIC_KEYMAP_LAYER_COUNT 16 #define DYNAMIC_KEYMAP_LAYER_COUNT 16
/* serial.c configuration for split keyboard */
#undef SOFT_SERIAL_PIN
#define SOFT_SERIAL_PIN D2

7
keyboards/handwired/dactyl_manuform/5x6_right_trackball/keymaps/default/config.h
View File

@ -19,9 +19,4 @@
#pragma once #pragma once
#define USE_SERIAL #include "../drashna/config.h"
#define MASTER_LEFT
// #define MASTER_RIGHT
//#define EE_HANDS
// Rows are doubled-up

48
keyboards/handwired/dactyl_manuform/5x6_right_trackball/keymaps/default/keymap.c
View File

@ -14,50 +14,4 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>. * along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
#include QMK_KEYBOARD_H // placeholder
#define _QWERTY 0
#define _LOWER 1
#define _RAISE 2
#define RAISE MO(_RAISE)
#define LOWER MO(_LOWER)
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
[_QWERTY] = LAYOUT_5x6_right_trackball(
KC_ESC , KC_1 , KC_2 , KC_3 , KC_4 , KC_5 , KC_6 , KC_7 , KC_8 , KC_9 , KC_0 ,KC_BSPC,
KC_TAB , KC_Q , KC_W , KC_E , KC_R , KC_T , KC_Y , KC_U , KC_I , KC_O , KC_P ,KC_MINS,
KC_LSFT, KC_A , KC_S , KC_D , KC_F , KC_G , KC_H , KC_J , KC_K , KC_L ,KC_SCLN,KC_QUOT,
KC_LCTL, KC_Z , KC_X , KC_C , KC_V , KC_B , KC_N , KC_M ,KC_COMM,KC_DOT ,KC_SLSH,KC_BSLASH,
KC_LBRC,KC_RBRC, KC_EQL,
RAISE,KC_SPC, LOWER,
KC_TAB,KC_HOME, KC_END, KC_DEL,
KC_BSPC, KC_GRV, KC_LGUI, KC_LALT
),
[_LOWER] = LAYOUT_5x6_right_trackball(
KC_TILD,KC_EXLM, KC_AT ,KC_HASH,KC_DLR ,KC_PERC, KC_CIRC,KC_AMPR,KC_ASTR,KC_LPRN,KC_RPRN,KC_DEL,
_______,_______,_______,_______,_______,KC_LBRC, KC_RBRC, KC_P7 , KC_P8 , KC_P9 ,_______,KC_PLUS,
_______,KC_HOME,KC_PGUP,KC_PGDN,KC_END ,KC_LPRN, KC_RPRN, KC_P4 , KC_P5 , KC_P6 ,KC_MINS,KC_PIPE,
_______,_______,_______,_______,_______,_______, _______, KC_P1 , KC_P2 , KC_P3 ,KC_EQL ,KC_UNDS,
_______,KC_PSCR, KC_P0,
_______,_______, _______,
_______,_______, _______,_______,
_______,_______, _______,_______
),
[_RAISE] = LAYOUT_5x6_right_trackball(
KC_F12 , KC_F1 , KC_F2 , KC_F3 , KC_F4 , KC_F5 , KC_F6 , KC_F7 , KC_F8 , KC_F9 ,KC_F10 ,KC_F11 ,
_______,_______,_______,_______,_______,KC_LBRC, KC_RBRC,_______,KC_NLCK,KC_INS ,KC_SLCK,KC_MUTE,
_______,KC_LEFT,KC_UP ,KC_DOWN,KC_RGHT,KC_LPRN, KC_RPRN,KC_MPRV,KC_MPLY,KC_MNXT,_______,KC_VOLU,
_______,_______,_______,_______,_______,_______, _______,_______,_______,_______,_______,KC_VOLD,
_______,_______, _______,
_______,_______, _______,
_______,_______, _______,_______,
_______,_______, _______,_______
),
};

4
keyboards/handwired/dactyl_manuform/5x6_right_trackball/keymaps/default/rules.mk Normal file
View File

@ -0,0 +1,4 @@
USER_NAME := drashna
SRC += ../drashna/keymap.c
include $(KEYBOARD_PATH_1)/keymaps/drashna/rules.mk

14
keyboards/handwired/dactyl_manuform/5x6_right_trackball/keymaps/drashna/config.h
View File

@ -17,6 +17,8 @@
#pragma once #pragma once
// #define USE_I2C // #define USE_I2C
#define SELECT_SOFT_SERIAL_SPEED 0
#define SERIAL_USE_MULTI_TRANSACTION
#define EE_HANDS #define EE_HANDS
#define TRACKBALL_DPI_OPTIONS \ #define TRACKBALL_DPI_OPTIONS \
@ -24,5 +26,17 @@
#define RGBLIGHT_EFFECT_TWINKLE_LIFE 50 #define RGBLIGHT_EFFECT_TWINKLE_LIFE 50
#define RGBLIGHT_EFFECT_TWINKLE_PROBABILITY 1/63 #define RGBLIGHT_EFFECT_TWINKLE_PROBABILITY 1/63
#define RGBLIGHT_MAX_BRIGHTNESS 100
#undef DEBOUNCE
#define DEBOUNCE 10
#define SOLENOID_PIN F1 #define SOLENOID_PIN F1
#define SOLENOID_DEFAULT_DWELL 8
#define OLED_DISPLAY_128X64
#define OLED_TIMEOUT 0
#define OLED_BRIGHTNESS 100
#define SPLIT_MODS_ENABLE
#define MK_KINETIC_SPEED

3
keyboards/handwired/dactyl_manuform/5x6_right_trackball/keymaps/drashna/keymap.c
View File

@ -17,7 +17,6 @@
#include "drashna.h" #include "drashna.h"
#define TG_DBLO TG(_DIABLO) #define TG_DBLO TG(_DIABLO)
#define _MOUSE _MEDIA
// clang-format off // clang-format off
@ -172,7 +171,7 @@ void process_mouse_user(report_mouse_t* mouse_report, int16_t x, int16_t y) {
} }
void matrix_scan_keymap(void) { void matrix_scan_keymap(void) {
if (timer_elapsed(mouse_timer) > 750 && layer_state_is(_MOUSE) && !mouse_keycode_tracker) { if (timer_elapsed(mouse_timer) > 650 && layer_state_is(_MOUSE) && !mouse_keycode_tracker) {
layer_off(_MOUSE); layer_off(_MOUSE);
} }
} }

11
keyboards/handwired/dactyl_manuform/5x6_right_trackball/keymaps/drashna/rules.mk
View File

@ -1,2 +1,9 @@
RGBLIGHT_STARTUP_ANIMATION = yes RGBLIGHT_STARTUP_ANIMATION = yes
HAPTIC_ENABLE = SOLENOID HAPTIC_ENABLE = SOLENOID
COMMAND_ENABLE = no
AUDIO_ENABLE = yes
TAP_DANCE_ENABLE = yes
UNICODE_ENABLE = yes
OLED_DRIVER_ENABLE = yes
# DEBOUNCE_TYPE = sym_eager_pk

164
keyboards/handwired/dactyl_manuform/5x6_right_trackball/pointer_transport.c
View File

@ -41,6 +41,10 @@ static uint16_t device_cpi = 0;
static int8_t split_mouse_x = 0, split_mouse_y = 0; static int8_t split_mouse_x = 0, split_mouse_y = 0;
#endif #endif
#ifdef OLED_DRIVER_ENABLE
# include "oled_driver.h"
#endif
#if defined(USE_I2C) #if defined(USE_I2C)
# include "i2c_master.h" # include "i2c_master.h"
@ -48,7 +52,16 @@ static int8_t split_mouse_x = 0, split_mouse_y = 0;
typedef struct _I2C_slave_buffer_t { typedef struct _I2C_slave_buffer_t {
matrix_row_t smatrix[ROWS_PER_HAND]; matrix_row_t smatrix[ROWS_PER_HAND];
uint8_t backlight_level; # ifdef SPLIT_MODS_ENABLE
uint8_t real_mods;
uint8_t weak_mods;
# ifndef NO_ACTION_ONESHOT
uint8_t oneshot_mods;
# endif
# endif
# ifdef BACKLIGHT_ENABLE
uint8_t backlight_level;
# endif
# if defined(RGBLIGHT_ENABLE) && defined(RGBLIGHT_SPLIT) # if defined(RGBLIGHT_ENABLE) && defined(RGBLIGHT_SPLIT)
rgblight_syncinfo_t rgblight_sync; rgblight_syncinfo_t rgblight_sync;
# endif # endif
@ -58,9 +71,12 @@ typedef struct _I2C_slave_buffer_t {
# ifdef WPM_ENABLE # ifdef WPM_ENABLE
uint8_t current_wpm; uint8_t current_wpm;
# endif # endif
int8_t mouse_x; int8_t mouse_x;
int8_t mouse_y; int8_t mouse_y;
uint16_t device_cpi; uint16_t device_cpi;
bool oled_on;
layer_state_t t_layer_state;
layer_state_t t_default_layer_state;
} I2C_slave_buffer_t; } I2C_slave_buffer_t;
static I2C_slave_buffer_t *const i2c_buffer = (I2C_slave_buffer_t *)i2c_slave_reg; static I2C_slave_buffer_t *const i2c_buffer = (I2C_slave_buffer_t *)i2c_slave_reg;
@ -68,11 +84,19 @@ static I2C_slave_buffer_t *const i2c_buffer = (I2C_slave_buffer_t *)i2c_slave_re
# define I2C_BACKLIGHT_START offsetof(I2C_slave_buffer_t, backlight_level) # define I2C_BACKLIGHT_START offsetof(I2C_slave_buffer_t, backlight_level)
# define I2C_RGB_START offsetof(I2C_slave_buffer_t, rgblight_sync) # define I2C_RGB_START offsetof(I2C_slave_buffer_t, rgblight_sync)
# define I2C_KEYMAP_START offsetof(I2C_slave_buffer_t, mmatrix) # define I2C_KEYMAP_START offsetof(I2C_slave_buffer_t, mmatrix)
# define I2C_SYNC_TIME_START offsetof(I2C_slave_buffer_t, sync_timer)
# define I2C_REAL_MODS_START offsetof(I2C_slave_buffer_t, real_mods)
# define I2C_WEAK_MODS_START offsetof(I2C_slave_buffer_t, weak_mods)
# define I2C_ONESHOT_MODS_START offsetof(I2C_slave_buffer_t, oneshot_mods)
# define I2C_ENCODER_START offsetof(I2C_slave_buffer_t, encoder_state) # define I2C_ENCODER_START offsetof(I2C_slave_buffer_t, encoder_state)
# define I2C_WPM_START offsetof(I2C_slave_buffer_t, current_wpm) # define I2C_WPM_START offsetof(I2C_slave_buffer_t, current_wpm)
# define I2C_MOUSE_X_START offsetof(I2C_slave_buffer_t, mouse_x) # define I2C_MOUSE_X_START offsetof(I2C_slave_buffer_t, mouse_x)
# define I2C_MOUSE_Y_START offsetof(I2C_slave_buffer_t, mouse_y) # define I2C_MOUSE_Y_START offsetof(I2C_slave_buffer_t, mouse_y)
# define I2C_MOUSE_DPI_START offsetof(I2C_slave_buffer_t, device_cpi) # define I2C_MOUSE_DPI_START offsetof(I2C_slave_buffer_t, device_cpi)
# define I2C_OLED_ON_START offsetof(I2C_slave_buffent, oled_on)
# define I2C_LAYER_STATE_START offsetof(I2C_slave_buffent, t_layer_state)
# define I2C_DEFAULT_LAYER_STATE_START offsetof(I2C_slave_buffent, t_default_layer_state)
# define TIMEOUT 100 # define TIMEOUT 100
# ifndef SLAVE_I2C_ADDRESS # ifndef SLAVE_I2C_ADDRESS
@ -127,13 +151,58 @@ bool transport_master(matrix_row_t matrix[]) {
pointing_device_set_report(temp_report); pointing_device_set_report(temp_report);
if (device_cpi != i2c_buffer->device_cpi) { if (device_cpi != i2c_buffer->device_cpi) {
if(i2c_writeReg(SLAVE_I2C_ADDRESS, I2C_MOUSE_DPI_START, (void *)&device_cpi, sizeof(device_cpi), TIMEOUT) >= 0) { if (i2c_writeReg(SLAVE_I2C_ADDRESS, I2C_MOUSE_DPI_START, (void *)&device_cpi, sizeof(device_cpi), TIMEOUT) >= 0) {
i2c_buffer->device_cpi = device_cpi i2c_buffer->device_cpi = device_cpi
} }
} }
} }
# endif # endif
# ifdef SPLIT_MODS_ENABLE
uint8_t real_mods = get_mods();
if (real_mods != i2c_buffer->real_mods) {
if (i2c_writeReg(SLAVE_I2C_ADDRESS, I2C_REAL_MODS_START, (void *)&real_mods, sizeof(real_mods), TIMEOUT) >= 0) {
i2c_buffer->real_mods = real_mods;
}
}
uint8_t weak_mods = get_weak_mods();
if (weak_mods != i2c_buffer->weak_mods) {
if (i2c_writeReg(SLAVE_I2C_ADDRESS, I2C_WEAK_MODS_START, (void *)&weak_mods, sizeof(weak_mods), TIMEOUT) >= 0) {
i2c_buffer->weak_mods = weak_mods;
}
}
# ifndef NO_ACTION_ONESHOT
uint8_t oneshot_mods = get_oneshot_mods();
if (oneshot_mods != i2c_buffer->oneshot_mods) {
if (i2c_writeReg(SLAVE_I2C_ADDRESS, I2C_ONESHOT_MODS_START, (void *)&oneshot_mods, sizeof(oneshot_mods), TIMEOUT) >= 0) {
i2c_buffer->oneshot_mods = oneshot_mods;
}
}
# endif
# endif
if (layer_state != i2c_buffer->t_layer_state) {
if (i2c_writeReg(SLAVE_I2C_ADDRESS, I2C_LAYER_STATE_START, (void *)&layer_state, sizeof(layer_state), TIMEOUT) >= 0) {
i2c_buffer->t_layer_state = layer_state;
}
}
if (default_layer_state != i2c_buffer->t_default_layer_state) {
if (i2c_writeReg(SLAVE_I2C_ADDRESS, I2C_DEFAULT_LAYER_STATE_START, (void *)&default_layer_state, sizeof(default_layer_state), TIMEOUT) >= 0) {
i2c_buffer->t_default_layer_state = default_layer_state;
}
}
# ifdef OLED_DRIVER_ENABLE
if (is_oled_on() != i2c_buffer->oled_on) {
if (i2c_writeReg(SLAVE_I2C_ADDRESS, I2C_LAYER_STATE_START, (void *)&is_oled_on(), sizeof(bool), TIMEOUT) >= 0) {
i2c_buffer->oled_on = is_oled_on();
}
}
# endif
return true; return true;
} }
@ -176,6 +245,29 @@ void transport_slave(matrix_row_t matrix[]) {
} }
# endif # endif
# ifdef SPLIT_MODS_ENABLE
set_mods(i2c_buffer->real_mods);
set_weak_mods(i2c_buffer->weak_mods);
# ifndef NO_ACTION_ONESHOT
set_oneshot_mods(i2c_buffer->oneshot_mods);
# endif
# endif
if (layer_state != i2c_buffer->t_layer_state) {
layer_state_set(i2c_buffer->t_layer_state);
}
if (default_layer_state != i2c_buffer->t_default_layer_state) {
default_layer_state_set(i2c_buffer->t_default_layer_state);
}
# ifdef OLED_DRIVER_ENABLE
if (i2c_buffer->oled_on) {
oled_on();
} else {
oled_off();
}
# endif
} }
void transport_master_init(void) { i2c_init(); } void transport_master_init(void) { i2c_init(); }
@ -190,20 +282,33 @@ typedef struct _Serial_s2m_buffer_t {
// TODO: if MATRIX_COLS > 8 change to uint8_t packed_matrix[] for pack/unpack // TODO: if MATRIX_COLS > 8 change to uint8_t packed_matrix[] for pack/unpack
matrix_row_t smatrix[ROWS_PER_HAND]; matrix_row_t smatrix[ROWS_PER_HAND];
# ifdef ENCODER_ENABLE # ifdef ENCODER_ENABLE
uint8_t encoder_state[NUMBER_OF_ENCODERS]; uint8_t encoder_state[NUMBER_OF_ENCODERS];
# endif # endif
int8_t mouse_x; int8_t mouse_x;
int8_t mouse_y; int8_t mouse_y;
} Serial_s2m_buffer_t; } Serial_s2m_buffer_t;
typedef struct _Serial_m2s_buffer_t { typedef struct _Serial_m2s_buffer_t {
# ifdef SPLIT_MODS_ENABLE
uint8_t real_mods;
uint8_t weak_mods;
# ifndef NO_ACTION_ONESHOT
uint8_t oneshot_mods;
# endif
# endif
# ifndef DISABLE_SYNC_TIMER
uint32_t sync_timer;
# endif
# ifdef BACKLIGHT_ENABLE # ifdef BACKLIGHT_ENABLE
uint8_t backlight_level; uint8_t backlight_level;
# endif # endif
# ifdef WPM_ENABLE # ifdef WPM_ENABLE
uint8_t current_wpm; uint8_t current_wpm;
# endif # endif
uint16_t device_cpi; uint16_t device_cpi;
bool oled_on;
layer_state_t t_layer_state;
layer_state_t t_default_layer_state;
} Serial_m2s_buffer_t; } Serial_m2s_buffer_t;
# if defined(RGBLIGHT_ENABLE) && defined(RGBLIGHT_SPLIT) # if defined(RGBLIGHT_ENABLE) && defined(RGBLIGHT_SPLIT)
@ -308,7 +413,15 @@ bool transport_master(matrix_row_t matrix[]) {
# ifdef WPM_ENABLE # ifdef WPM_ENABLE
// Write wpm to slave // Write wpm to slave
serial_m2s_buffer.current_wpm = get_current_wpm(); serial_m2s_buffer.current_wpm = get_current_wpm();
# endif
# ifdef SPLIT_MODS_ENABLE
serial_m2s_buffer.real_mods = get_mods();
serial_m2s_buffer.weak_mods = get_weak_mods();
# ifndef NO_ACTION_ONESHOT
serial_m2s_buffer.oneshot_mods = get_oneshot_mods();
# endif
# endif # endif
# ifdef POINTING_DEVICE_ENABLE # ifdef POINTING_DEVICE_ENABLE
@ -321,6 +434,12 @@ bool transport_master(matrix_row_t matrix[]) {
} }
# endif # endif
serial_m2s_buffer.t_layer_state = layer_state;
serial_m2s_buffer.t_default_layer_state = default_layer_state;
# ifdef OLED_DRIVER_ENABLE
serial_m2s_buffer.oled_on = is_oled_on();
# endif
return true; return true;
} }
@ -344,6 +463,14 @@ void transport_slave(matrix_row_t matrix[]) {
set_current_wpm(serial_m2s_buffer.current_wpm); set_current_wpm(serial_m2s_buffer.current_wpm);
# endif # endif
# ifdef SPLIT_MODS_ENABLE
set_mods(serial_m2s_buffer.real_mods);
set_weak_mods(serial_m2s_buffer.weak_mods);
# ifndef NO_ACTION_ONESHOT
set_oneshot_mods(serial_m2s_buffer.oneshot_mods);
# endif
# endif
# ifdef POINTING_DEVICE_ENABLE # ifdef POINTING_DEVICE_ENABLE
if (!is_keyboard_left()) { if (!is_keyboard_left()) {
static uint16_t cpi; static uint16_t cpi;
@ -354,7 +481,20 @@ void transport_slave(matrix_row_t matrix[]) {
serial_s2m_buffer.mouse_x = split_mouse_x; serial_s2m_buffer.mouse_x = split_mouse_x;
serial_s2m_buffer.mouse_y = split_mouse_y; serial_s2m_buffer.mouse_y = split_mouse_y;
} }
# endif
if (layer_state != serial_m2s_buffer.t_layer_state) {
layer_state_set(serial_m2s_buffer.t_layer_state);
}
if (default_layer_state != serial_m2s_buffer.t_default_layer_state) {
default_layer_set(serial_m2s_buffer.t_default_layer_state);
}
# ifdef OLED_DRIVER_ENABLE
if (serial_m2s_buffer.oled_on) {
oled_on();
} else {
oled_off();
}
# endif # endif
} }

4
keyboards/kyria/keymaps/drashna/config.h
View File

@ -35,8 +35,4 @@
# define RGBLIGHT_LAYERS # define RGBLIGHT_LAYERS
#endif #endif
// If you are using an Elite C rev3 on the slave side, uncomment the lines below:
#define SPLIT_USB_DETECT
#define SPLIT_USB_TIMEOUT 1000
#define KEYLOGGER_LENGTH 10 #define KEYLOGGER_LENGTH 10

4
keyboards/kyria/keymaps/drashna/rules.mk
View File

@ -18,6 +18,6 @@ FAUXCLICKY_ENABLE = no # Use buzzer to emulate clicky switches
BOOTLOADER = atmel-dfu BOOTLOADER = atmel-dfu
SPLIT_TRANSPORT = mirror # SPLIT_TRANSPORT = mirror
TAP_DANCE_ENABLE = yes # TAP_DANCE_ENABLE = yes

37
keyboards/moonlander/keymaps/drashna/keymap.c
View File

@ -196,14 +196,7 @@ bool process_record_keymap(uint16_t keycode, keyrecord_t *record) {
} }
#ifdef RGB_MATRIX_ENABLE #ifdef RGB_MATRIX_ENABLE
# ifndef RGB_MATRIX_INDICATOR_SET_COLOR
# define RGB_MATRIX_INDICATOR_SET_COLOR(i, r, g, b) rgb_matrix_set_color(i, r, g, b)
void rgb_matrix_indicators_user(void) {
#else
void rgb_matrix_indicators_advanced_user(uint8_t led_min, uint8_t led_max) { void rgb_matrix_indicators_advanced_user(uint8_t led_min, uint8_t led_max) {
# endif
if (g_suspend_state || !rgb_matrix_config.enable) return;
if (layer_state_is(_GAMEPAD)) { if (layer_state_is(_GAMEPAD)) {
RGB_MATRIX_INDICATOR_SET_COLOR(11, 0x00, 0xFF, 0x00); // Q RGB_MATRIX_INDICATOR_SET_COLOR(11, 0x00, 0xFF, 0x00); // Q
RGB_MATRIX_INDICATOR_SET_COLOR(16, 0x00, 0xFF, 0xFF); // W RGB_MATRIX_INDICATOR_SET_COLOR(16, 0x00, 0xFF, 0xFF); // W
@ -214,51 +207,51 @@ void rgb_matrix_indicators_advanced_user(uint8_t led_min, uint8_t led_max) {
RGB_MATRIX_INDICATOR_SET_COLOR(22, 0x00, 0xFF, 0xFF); // D RGB_MATRIX_INDICATOR_SET_COLOR(22, 0x00, 0xFF, 0xFF); // D
RGB_MATRIX_INDICATOR_SET_COLOR(27, 0x7A, 0x00, 0xFF); // F RGB_MATRIX_INDICATOR_SET_COLOR(27, 0x7A, 0x00, 0xFF); // F
RGB_MATRIX_INDICATOR_SET_COLOR((userspace_config.swapped_numbers ? 10 : 15), 0xFF, 0xFF, 0xFF); // 1 RGB_MATRIX_INDICATOR_SET_COLOR((userspace_config.swapped_numbers ? 15 : 10), 0xFF, 0xFF, 0xFF); // 1
RGB_MATRIX_INDICATOR_SET_COLOR((userspace_config.swapped_numbers ? 15 : 10), 0x00, 0xFF, 0x00); // 2 RGB_MATRIX_INDICATOR_SET_COLOR((userspace_config.swapped_numbers ? 10 : 15), 0x00, 0xFF, 0x00); // 2
RGB_MATRIX_INDICATOR_SET_COLOR(20, 0x7A, 0x00, 0xFF); // 3 RGB_MATRIX_INDICATOR_SET_COLOR(20, 0x7A, 0x00, 0xFF); // 3
} }
if (userspace_config.rgb_layer_change) { if (userspace_config.rgb_layer_change) {
switch (get_highest_layer(layer_state|default_layer_state)) { switch (get_highest_layer(layer_state|default_layer_state)) {
case _QWERTY: case _QWERTY:
rgb_matrix_layer_helper(HSV_CYAN, 0, rgb_matrix_config.speed, LED_FLAG_MODIFIER); rgb_matrix_layer_helper(HSV_CYAN, 0, rgb_matrix_config.speed, LED_FLAG_MODIFIER, led_min, led_max);
break; break;
case _COLEMAK: case _COLEMAK:
rgb_matrix_layer_helper(HSV_MAGENTA, 0, rgb_matrix_config.speed, LED_FLAG_MODIFIER); rgb_matrix_layer_helper(HSV_MAGENTA, 0, rgb_matrix_config.speed, LED_FLAG_MODIFIER, led_min, led_max);
break; break;
case _DVORAK: case _DVORAK:
rgb_matrix_layer_helper(HSV_SPRINGGREEN, 0, rgb_matrix_config.speed, LED_FLAG_MODIFIER); rgb_matrix_layer_helper(HSV_SPRINGGREEN, 0, rgb_matrix_config.speed, LED_FLAG_MODIFIER, led_min, led_max);
break; break;
case _WORKMAN: case _WORKMAN:
rgb_matrix_layer_helper(HSV_GOLDENROD, 0, rgb_matrix_config.speed, LED_FLAG_MODIFIER); rgb_matrix_layer_helper(HSV_GOLDENROD, 0, rgb_matrix_config.speed, LED_FLAG_MODIFIER, led_min, led_max);
break; break;
case _NORMAN: case _NORMAN:
rgb_matrix_layer_helper(HSV_CORAL, 0, rgb_matrix_config.speed, LED_FLAG_MODIFIER); rgb_matrix_layer_helper(HSV_CORAL, 0, rgb_matrix_config.speed, LED_FLAG_MODIFIER, led_min, led_max);
break; break;
case _MALTRON: case _MALTRON:
rgb_matrix_layer_helper(HSV_YELLOW, 0, rgb_matrix_config.speed, LED_FLAG_MODIFIER); rgb_matrix_layer_helper(HSV_YELLOW, 0, rgb_matrix_config.speed, LED_FLAG_MODIFIER, led_min, led_max);
break; break;
case _EUCALYN: case _EUCALYN:
rgb_matrix_layer_helper(HSV_PINK, 0, rgb_matrix_config.speed, LED_FLAG_MODIFIER); rgb_matrix_layer_helper(HSV_PINK, 0, rgb_matrix_config.speed, LED_FLAG_MODIFIER, led_min, led_max);
break; break;
case _CARPLAX: case _CARPLAX:
rgb_matrix_layer_helper(HSV_BLUE, 0, rgb_matrix_config.speed, LED_FLAG_MODIFIER); rgb_matrix_layer_helper(HSV_BLUE, 0, rgb_matrix_config.speed, LED_FLAG_MODIFIER, led_min, led_max);
break; break;
case _GAMEPAD: case _GAMEPAD:
rgb_matrix_layer_helper(HSV_ORANGE, 1, rgb_matrix_config.speed, LED_FLAG_MODIFIER); rgb_matrix_layer_helper(HSV_ORANGE, 1, rgb_matrix_config.speed, LED_FLAG_MODIFIER, led_min, led_max);
break; break;
case _DIABLO: case _DIABLO:
rgb_matrix_layer_helper(HSV_RED, 1, rgb_matrix_config.speed * 8, LED_FLAG_MODIFIER); rgb_matrix_layer_helper(HSV_RED, 1, rgb_matrix_config.speed * 8, LED_FLAG_MODIFIER, led_min, led_max);
break; break;
case _RAISE: case _RAISE:
rgb_matrix_layer_helper(HSV_YELLOW, 1, rgb_matrix_config.speed, LED_FLAG_MODIFIER); rgb_matrix_layer_helper(HSV_YELLOW, 1, rgb_matrix_config.speed, LED_FLAG_MODIFIER, led_min, led_max);
break; break;
case _LOWER: case _LOWER:
rgb_matrix_layer_helper(HSV_GREEN, 1, rgb_matrix_config.speed, LED_FLAG_MODIFIER); rgb_matrix_layer_helper(HSV_GREEN, 1, rgb_matrix_config.speed, LED_FLAG_MODIFIER, led_min, led_max);
break; break;
case _ADJUST: case _ADJUST:
rgb_matrix_layer_helper(HSV_RED, 1, rgb_matrix_config.speed, LED_FLAG_MODIFIER); rgb_matrix_layer_helper(HSV_RED, 1, rgb_matrix_config.speed, LED_FLAG_MODIFIER, led_min, led_max);
break; break;
} }
} }

24
keyboards/ploopyco/mouse/keymaps/drashna/config.h Normal file
View File

@ -0,0 +1,24 @@
/* Copyright 2020 Christopher Courtney, aka Drashna Jael're (@drashna) <drashna@live.com>
* Copyright 2019 Sunjun Kim
* Copyright 2020 Ploopy Corporation
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#undef RGBLIGHT_LIMIT_VAL
#define RGBLIGHT_LIMIT_VAL 255
#define RGBLIGHT_ANIMATIONS
#define RGBLIGHT_SLEEP

34
keyboards/ploopyco/mouse/keymaps/drashna/keymap.c Normal file
View File

@ -0,0 +1,34 @@
/* Copyright 2020 Christopher Courtney, aka Drashna Jael're (@drashna) <drashna@live.com>
* Copyright 2019 Sunjun Kim
* Copyright 2020 Ploopy Corporation
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include QMK_KEYBOARD_H
// safe range starts at `PLOOPY_SAFE_RANGE` instead.
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
[0] = LAYOUT(/* Base */
C(KC_C), KC_BTN1, KC_BTN3, KC_BTN2, MO(1), KC_BTN4, KC_BTN5, DPI_CONFIG),
[1] = LAYOUT(/* Base */
RGB_HUI, RGB_MOD, RGB_TOG, RGB_RMOD, MO(1), KC_VOLU, KC_VOLD, RESET)
};
void eeconkfig_init_user(void) {
rgblight_enable();
rgblight_mode(RGBLIGHT_MODE_TWINKLE+5);
rgblight_sethsv(HSV_MAGENTA);
}

4
keyboards/ploopyco/mouse/keymaps/drashna/rules.mk Normal file
View File

@ -0,0 +1,4 @@
USER_NAME := not_drashna
RGBLIGHT_ENABLE = yes
CONSOLE_ENABLE = no

1
layouts/community/ergodox/drashna/config.h
View File

@ -42,7 +42,6 @@
# undef RGB_MATRIX_LED_FLUSH_LIMIT # undef RGB_MATRIX_LED_FLUSH_LIMIT
# if defined(RGBLIGHT_ENABLE) && defined(RGB_MATRIX_ENABLE) # if defined(RGBLIGHT_ENABLE) && defined(RGB_MATRIX_ENABLE)
# define RGBLIGHT_LIMIT_VAL 100 # define RGBLIGHT_LIMIT_VAL 100
# undef RGBLIGHT_SLEEP
# endif # endif
#endif #endif

61
layouts/community/ergodox/drashna/keymap.c
View File

@ -446,70 +446,65 @@ void suspend_power_down_keymap(void) { rgb_matrix_set_suspend_state(true); }
void suspend_wakeup_init_keymap(void) { rgb_matrix_set_suspend_state(false); } void suspend_wakeup_init_keymap(void) { rgb_matrix_set_suspend_state(false); }
void rgb_matrix_indicators_user(void) { void rgb_matrix_indicators_advanced_user(uint8_t led_min, uint8_t led_max) {
if (g_suspend_state || !rgb_matrix_config.enable) return;
if (layer_state_is(_GAMEPAD)) { if (layer_state_is(_GAMEPAD)) {
rgb_matrix_set_color(32, 0x00, 0xFF, 0x00); // Q RGB_MATRIX_INDICATOR_SET_COLOR(32, 0x00, 0xFF, 0x00); // Q
rgb_matrix_set_color(31, 0x00, 0xFF, 0xFF); // W RGB_MATRIX_INDICATOR_SET_COLOR(31, 0x00, 0xFF, 0xFF); // W
rgb_matrix_set_color(30, 0xFF, 0x00, 0x00); // E RGB_MATRIX_INDICATOR_SET_COLOR(30, 0xFF, 0x00, 0x00); // E
rgb_matrix_set_color(29, 0xFF, 0x80, 0x00); // R RGB_MATRIX_INDICATOR_SET_COLOR(29, 0xFF, 0x80, 0x00); // R
rgb_matrix_set_color(37, 0x00, 0xFF, 0xFF); // A RGB_MATRIX_INDICATOR_SET_COLOR(37, 0x00, 0xFF, 0xFF); // A
rgb_matrix_set_color(36, 0x00, 0xFF, 0xFF); // S RGB_MATRIX_INDICATOR_SET_COLOR(36, 0x00, 0xFF, 0xFF); // S
rgb_matrix_set_color(35, 0x00, 0xFF, 0xFF); // D RGB_MATRIX_INDICATOR_SET_COLOR(35, 0x00, 0xFF, 0xFF); // D
rgb_matrix_set_color(34, 0x7A, 0x00, 0xFF); // F RGB_MATRIX_INDICATOR_SET_COLOR(34, 0x7A, 0x00, 0xFF); // F
rgb_matrix_set_color(userspace_config.swapped_numbers ? 27 : 26, 0xFF, 0xFF, 0xFF); // 1 RGB_MATRIX_INDICATOR_SET_COLOR((userspace_config.swapped_numbers ? 26 : 27), 0xFF, 0xFF, 0xFF); // 1
rgb_matrix_set_color(userspace_config.swapped_numbers ? 26 : 27, 0x00, 0xFF, 0x00); // 2 RGB_MATRIX_INDICATOR_SET_COLOR((userspace_config.swapped_numbers ? 27 : 26), 0x00, 0xFF, 0x00); // 2
rgb_matrix_set_color(25, 0x7A, 0x00, 0xFF); // 3 RGB_MATRIX_INDICATOR_SET_COLOR(25, 0x7A, 0x00, 0xFF); // 3
} }
# if defined(RGBLIGHT_ENABLE)
if (!userspace_config.rgb_layer_change) if (userspace_config.rgb_layer_change) {
# else
if (userspace_config.rgb_layer_change)
# endif
{
bool mods_enabled = IS_LAYER_ON(_MODS); bool mods_enabled = IS_LAYER_ON(_MODS);
switch (get_highest_layer(layer_state|default_layer_state)) { switch (get_highest_layer(layer_state|default_layer_state)) {
case _GAMEPAD: case _GAMEPAD:
rgb_matrix_layer_helper(HSV_ORANGE, 1, rgb_matrix_config.speed, LED_FLAG_MODIFIER); rgb_matrix_layer_helper(HSV_ORANGE, 1, rgb_matrix_config.speed, LED_FLAG_MODIFIER, led_min, led_max);
break; break;
case _DIABLO: case _DIABLO:
rgb_matrix_layer_helper(HSV_RED, 1, rgb_matrix_config.speed * 8, LED_FLAG_MODIFIER); rgb_matrix_layer_helper(HSV_RED, 1, rgb_matrix_config.speed * 8, LED_FLAG_MODIFIER, led_min, led_max);
break; break;
case _RAISE: case _RAISE:
rgb_matrix_layer_helper(HSV_YELLOW, 1, rgb_matrix_config.speed, LED_FLAG_MODIFIER); rgb_matrix_layer_helper(HSV_YELLOW, 1, rgb_matrix_config.speed, LED_FLAG_MODIFIER, led_min, led_max);
break; break;
case _LOWER: case _LOWER:
rgb_matrix_layer_helper(HSV_GREEN, 1, rgb_matrix_config.speed, LED_FLAG_MODIFIER); rgb_matrix_layer_helper(HSV_GREEN, 1, rgb_matrix_config.speed, LED_FLAG_MODIFIER, led_min, led_max);
break; break;
case _ADJUST: case _ADJUST:
rgb_matrix_layer_helper(HSV_RED, 1, rgb_matrix_config.speed, LED_FLAG_MODIFIER); rgb_matrix_layer_helper(HSV_RED, 1, rgb_matrix_config.speed, LED_FLAG_MODIFIER, led_min, led_max);
break; break;
case _QWERTY: case _QWERTY:
rgb_matrix_layer_helper(HSV_CYAN, mods_enabled, rgb_matrix_config.speed, LED_FLAG_MODIFIER); rgb_matrix_layer_helper(HSV_CYAN, mods_enabled, rgb_matrix_config.speed, LED_FLAG_MODIFIER, led_min, led_max);
break; break;
case _COLEMAK: case _COLEMAK:
rgb_matrix_layer_helper(HSV_MAGENTA, mods_enabled, rgb_matrix_config.speed, LED_FLAG_MODIFIER); rgb_matrix_layer_helper(HSV_MAGENTA, mods_enabled, rgb_matrix_config.speed, LED_FLAG_MODIFIER, led_min, led_max);
break; break;
case _DVORAK: case _DVORAK:
rgb_matrix_layer_helper(HSV_SPRINGGREEN, mods_enabled, rgb_matrix_config.speed, LED_FLAG_MODIFIER); rgb_matrix_layer_helper(HSV_SPRINGGREEN, mods_enabled, rgb_matrix_config.speed, LED_FLAG_MODIFIER, led_min, led_max);
break; break;
case _WORKMAN: case _WORKMAN:
rgb_matrix_layer_helper(HSV_GOLDENROD, mods_enabled, rgb_matrix_config.speed, LED_FLAG_MODIFIER); rgb_matrix_layer_helper(HSV_GOLDENROD, mods_enabled, rgb_matrix_config.speed, LED_FLAG_MODIFIER, led_min, led_max);
break; break;
case _NORMAN: case _NORMAN:
rgb_matrix_layer_helper(HSV_CORAL, mods_enabled, rgb_matrix_config.speed, LED_FLAG_MODIFIER); rgb_matrix_layer_helper(HSV_CORAL, mods_enabled, rgb_matrix_config.speed, LED_FLAG_MODIFIER, led_min, led_max);
break; break;
case _MALTRON: case _MALTRON:
rgb_matrix_layer_helper(HSV_YELLOW, mods_enabled, rgb_matrix_config.speed, LED_FLAG_MODIFIER); rgb_matrix_layer_helper(HSV_YELLOW, mods_enabled, rgb_matrix_config.speed, LED_FLAG_MODIFIER, led_min, led_max);
break; break;
case _EUCALYN: case _EUCALYN:
rgb_matrix_layer_helper(HSV_PINK, mods_enabled, rgb_matrix_config.speed, LED_FLAG_MODIFIER); rgb_matrix_layer_helper(HSV_PINK, mods_enabled, rgb_matrix_config.speed, LED_FLAG_MODIFIER, led_min, led_max);
break; break;
case _CARPLAX: case _CARPLAX:
rgb_matrix_layer_helper(HSV_BLUE, mods_enabled, rgb_matrix_config.speed, LED_FLAG_MODIFIER); rgb_matrix_layer_helper(HSV_BLUE, mods_enabled, rgb_matrix_config.speed, LED_FLAG_MODIFIER, led_min, led_max);
break; break;
} }
} }
@ -517,6 +512,7 @@ void rgb_matrix_indicators_user(void) {
#endif // RGB_MATRIX_INIT #endif // RGB_MATRIX_INIT
#ifdef TAPPING_TERM_PER_KEY
uint16_t get_tapping_term(uint16_t keycode, keyrecord_t *record) { uint16_t get_tapping_term(uint16_t keycode, keyrecord_t *record) {
if (keycode >= QK_MOD_TAP && keycode <= QK_MOD_TAP_MAX) { if (keycode >= QK_MOD_TAP && keycode <= QK_MOD_TAP_MAX) {
if (mod_config(keycode & 0xf) & MOD_MASK_ALT) { if (mod_config(keycode & 0xf) & MOD_MASK_ALT) {
@ -525,3 +521,4 @@ uint16_t get_tapping_term(uint16_t keycode, keyrecord_t *record) {
} }
return TAPPING_TERM; return TAPPING_TERM;
} }
#endif

77
layouts/community/ergodox/drashna/visualizer.c Normal file
View File

@ -0,0 +1,77 @@
/*
Copyright 2017 Fred Sundvik
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "./simple_visualizer.h"
#include "util.h"
#include "drashna.h"
#include "rgblight_list.h"
#define LCD_COLOR_wrapper(...) LCD_COLOR(__VA_ARGS__)
// This function should be implemented by the keymap visualizer
// Don't change anything else than state->target_lcd_color and state->layer_text as that's the only thing
// that the simple_visualizer assumes that you are updating
// Also make sure that the buffer passed to state->layer_text remains valid until the previous animation is
// stopped. This can be done by either double buffering it or by using constant strings
static void get_visualizer_layer_and_color(visualizer_state_t* state) {
switch(get_highest_layer(state->status.layer|default_layer_state)) {
case _LOWER:
state->layer_text = "Lower";
state->target_lcd_color = LCD_COLOR_wrapper(HSV_GREEN);
break;
case _RAISE:
state->layer_text = "Raise";
state->target_lcd_color = LCD_COLOR_wrapper(HSV_YELLOW);
break;
case _ADJUST:
state->layer_text = "Adjust";
state->target_lcd_color = LCD_COLOR_wrapper(HSV_RED);
break;
case _MACROS:
state->layer_text = "Macros";
state->target_lcd_color = LCD_COLOR_wrapper(HSV_ORANGE);
break;
case _MEDIA:
state->layer_text = "Media";
state->target_lcd_color = LCD_COLOR_wrapper(HSV_CHARTREUSE);
break;
case _GAMEPAD:
state->layer_text = "Game";
state->target_lcd_color = LCD_COLOR_wrapper(HSV_ORANGE);
break;
case _QWERTY:
state->layer_text = "QWERTY";
state->target_lcd_color = LCD_COLOR_wrapper(HSV_CYAN);
break;
case _WORKMAN:
state->layer_text = "Workman";
state->target_lcd_color = LCD_COLOR_wrapper(HSV_GOLDENROD);
break;
case _DVORAK:
state->layer_text = "Dvorak";
state->target_lcd_color = LCD_COLOR_wrapper(HSV_SPRINGGREEN);
break;
case _COLEMAK:
state->layer_text = "Colemak";
state->target_lcd_color = LCD_COLOR_wrapper(HSV_MAGENTA);
break; break;
default:
state->layer_text = "NONE";
state->target_lcd_color = LCD_COLOR_wrapper(HSV_RED);
break;
}
}

2
layouts/community/ortho_4x12/drashna/config.h
View File

@ -77,6 +77,8 @@
# define PRODUCT Drashna Hacked Planck EZ # define PRODUCT Drashna Hacked Planck EZ
# endif # endif
#endif #endif
#undef NO_USB_STARTUP_CHECK
#define EEPROM_I2C_RM24C512C #define EEPROM_I2C_RM24C512C

56
layouts/community/ortho_4x12/drashna/keymap.c
View File

@ -16,9 +16,6 @@
#include "drashna.h" #include "drashna.h"
#ifdef RGBLIGHT_ENABLE
extern rgblight_config_t rgblight_config;
#endif
#ifdef BACKLIGHT_ENABLE #ifdef BACKLIGHT_ENABLE
enum planck_keycodes { enum planck_keycodes {
@ -231,7 +228,8 @@ void suspend_wakeup_init_keymap(void) {
} }
// clang-format on // clang-format on
void rgb_matrix_indicators_user(void) {
void rgb_matrix_indicators_advanced_user(uint8_t led_min, uint8_t led_max) {
uint8_t this_mod = get_mods(); uint8_t this_mod = get_mods();
uint8_t this_led = host_keyboard_leds(); uint8_t this_led = host_keyboard_leds();
uint8_t this_osm = get_oneshot_mods(); uint8_t this_osm = get_oneshot_mods();
@ -240,8 +238,6 @@ void rgb_matrix_indicators_user(void) {
is_ez = true; is_ez = true;
# endif # endif
if (g_suspend_state || !rgb_matrix_config.enable) return;
# if defined(RGBLIGHT_ENABLE) # if defined(RGBLIGHT_ENABLE)
if (!userspace_config.rgb_layer_change) if (!userspace_config.rgb_layer_change)
# else # else
@ -250,46 +246,46 @@ void rgb_matrix_indicators_user(void) {
{ {
switch (get_highest_layer(layer_state)) { switch (get_highest_layer(layer_state)) {
case _GAMEPAD: case _GAMEPAD:
rgb_matrix_layer_helper(HSV_ORANGE, 1, rgb_matrix_config.speed, LED_FLAG_MODIFIER); rgb_matrix_layer_helper(HSV_ORANGE, 1, rgb_matrix_config.speed, LED_FLAG_MODIFIER, led_min, led_max);
break; break;
case _DIABLO: case _DIABLO:
rgb_matrix_layer_helper(HSV_RED, 1, rgb_matrix_config.speed * 8, LED_FLAG_MODIFIER); rgb_matrix_layer_helper(HSV_RED, 1, rgb_matrix_config.speed * 8, LED_FLAG_MODIFIER, led_min, led_max);
break; break;
case _RAISE: case _RAISE:
rgb_matrix_layer_helper(HSV_YELLOW, 1, rgb_matrix_config.speed, LED_FLAG_MODIFIER); rgb_matrix_layer_helper(HSV_YELLOW, 1, rgb_matrix_config.speed, LED_FLAG_MODIFIER, led_min, led_max);
break; break;
case _LOWER: case _LOWER:
rgb_matrix_layer_helper(HSV_GREEN, 1, rgb_matrix_config.speed, LED_FLAG_MODIFIER); rgb_matrix_layer_helper(HSV_GREEN, 1, rgb_matrix_config.speed, LED_FLAG_MODIFIER, led_min, led_max);
break; break;
case _ADJUST: case _ADJUST:
rgb_matrix_layer_helper(HSV_RED, 1, rgb_matrix_config.speed, LED_FLAG_MODIFIER); rgb_matrix_layer_helper(HSV_RED, 1, rgb_matrix_config.speed, LED_FLAG_MODIFIER, led_min, led_max);
break; break;
default: { default: {
bool mods_enabled = IS_LAYER_ON(_MODS); bool mods_enabled = IS_LAYER_ON(_MODS);
switch (get_highest_layer(default_layer_state)) { switch (get_highest_layer(default_layer_state)) {
case _QWERTY: case _QWERTY:
rgb_matrix_layer_helper(HSV_CYAN, mods_enabled, rgb_matrix_config.speed, LED_FLAG_MODIFIER); rgb_matrix_layer_helper(HSV_CYAN, mods_enabled, rgb_matrix_config.speed, LED_FLAG_MODIFIER, led_min, led_max);
break; break;
case _COLEMAK: case _COLEMAK:
rgb_matrix_layer_helper(HSV_MAGENTA, mods_enabled, rgb_matrix_config.speed, LED_FLAG_MODIFIER); rgb_matrix_layer_helper(HSV_MAGENTA, mods_enabled, rgb_matrix_config.speed, LED_FLAG_MODIFIER, led_min, led_max);
break; break;
case _DVORAK: case _DVORAK:
rgb_matrix_layer_helper(HSV_SPRINGGREEN, mods_enabled, rgb_matrix_config.speed, LED_FLAG_MODIFIER); rgb_matrix_layer_helper(HSV_SPRINGGREEN, mods_enabled, rgb_matrix_config.speed, LED_FLAG_MODIFIER, led_min, led_max);
break; break;
case _WORKMAN: case _WORKMAN:
rgb_matrix_layer_helper(HSV_GOLDENROD, mods_enabled, rgb_matrix_config.speed, LED_FLAG_MODIFIER); rgb_matrix_layer_helper(HSV_GOLDENROD, mods_enabled, rgb_matrix_config.speed, LED_FLAG_MODIFIER, led_min, led_max);
break; break;
case _NORMAN: case _NORMAN:
rgb_matrix_layer_helper(HSV_CORAL, mods_enabled, rgb_matrix_config.speed, LED_FLAG_MODIFIER); rgb_matrix_layer_helper(HSV_CORAL, mods_enabled, rgb_matrix_config.speed, LED_FLAG_MODIFIER, led_min, led_max);
break; break;
case _MALTRON: case _MALTRON:
rgb_matrix_layer_helper(HSV_YELLOW, mods_enabled, rgb_matrix_config.speed, LED_FLAG_MODIFIER); rgb_matrix_layer_helper(HSV_YELLOW, mods_enabled, rgb_matrix_config.speed, LED_FLAG_MODIFIER, led_min, led_max);
break; break;
case _EUCALYN: case _EUCALYN:
rgb_matrix_layer_helper(HSV_PINK, mods_enabled, rgb_matrix_config.speed, LED_FLAG_MODIFIER); rgb_matrix_layer_helper(HSV_PINK, mods_enabled, rgb_matrix_config.speed, LED_FLAG_MODIFIER, led_min, led_max);
break; break;
case _CARPLAX: case _CARPLAX:
rgb_matrix_layer_helper(HSV_BLUE, mods_enabled, rgb_matrix_config.speed, LED_FLAG_MODIFIER); rgb_matrix_layer_helper(HSV_BLUE, mods_enabled, rgb_matrix_config.speed, LED_FLAG_MODIFIER, led_min, led_max);
break; break;
} }
break; break;
@ -299,35 +295,35 @@ void rgb_matrix_indicators_user(void) {
switch (get_highest_layer(default_layer_state)) { switch (get_highest_layer(default_layer_state)) {
case _QWERTY: case _QWERTY:
rgb_matrix_set_color(is_ez ? 41 : 42, 0x00, 0xFF, 0xFF); RGB_MATRIX_INDICATOR_SET_COLOR((is_ez ? 41 : 42), 0x00, 0xFF, 0xFF);
break; break;
case _COLEMAK: case _COLEMAK:
rgb_matrix_set_color(is_ez ? 41 : 42, 0xFF, 0x00, 0xFF); RGB_MATRIX_INDICATOR_SET_COLOR((is_ez ? 41 : 42), 0xFF, 0x00, 0xFF);
break; break;
case _DVORAK: case _DVORAK:
rgb_matrix_set_color(is_ez ? 41 : 42, 0x00, 0xFF, 0x00); RGB_MATRIX_INDICATOR_SET_COLOR((is_ez ? 41 : 42), 0x00, 0xFF, 0x00);
break; break;
case _WORKMAN: case _WORKMAN:
rgb_matrix_set_color(is_ez ? 41 : 42, 0xD9, 0xA5, 0x21); RGB_MATRIX_INDICATOR_SET_COLOR((is_ez ? 41 : 42), 0xD9, 0xA5, 0x21);
break; break;
} }
if ((this_mod | this_osm) & MOD_MASK_SHIFT || this_led & (1 << USB_LED_CAPS_LOCK)) { if ((this_mod | this_osm) & MOD_MASK_SHIFT || this_led & (1 << USB_LED_CAPS_LOCK)) {
if (!layer_state_cmp(layer_state, _ADJUST)) { if (!layer_state_cmp(layer_state, _ADJUST)) {
rgb_matrix_set_color(24, 0x00, 0xFF, 0x00); RGB_MATRIX_INDICATOR_SET_COLOR(24, 0x00, 0xFF, 0x00);
} }
rgb_matrix_set_color(36, 0x00, 0xFF, 0x00); RGB_MATRIX_INDICATOR_SET_COLOR(36, 0x00, 0xFF, 0x00);
} }
if ((this_mod | this_osm) & MOD_MASK_CTRL) { if ((this_mod | this_osm) & MOD_MASK_CTRL) {
rgb_matrix_set_color(25, 0xFF, 0x00, 0x00); RGB_MATRIX_INDICATOR_SET_COLOR(25, 0xFF, 0x00, 0x00);
rgb_matrix_set_color(34, 0xFF, 0x00, 0x00); RGB_MATRIX_INDICATOR_SET_COLOR(34, 0xFF, 0x00, 0x00);
rgb_matrix_set_color(37, 0xFF, 0x00, 0x00); RGB_MATRIX_INDICATOR_SET_COLOR(37, 0xFF, 0x00, 0x00);
} }
if ((this_mod | this_osm) & MOD_MASK_GUI) { if ((this_mod | this_osm) & MOD_MASK_GUI) {
rgb_matrix_set_color(39, 0xFF, 0xD9, 0x00); RGB_MATRIX_INDICATOR_SET_COLOR(39, 0xFF, 0xD9, 0x00);
} }
if ((this_mod | this_osm) & MOD_MASK_ALT) { if ((this_mod | this_osm) & MOD_MASK_ALT) {
rgb_matrix_set_color(38, 0x00, 0x00, 0xFF); RGB_MATRIX_INDICATOR_SET_COLOR(38, 0x00, 0x00, 0xFF);
} }
} }

36
layouts/community/split_3x6_3/drashna/config.h
View File

@ -19,14 +19,11 @@
/* Select hand configuration */ /* Select hand configuration */
// #define MASTER_LEFT // #define MASTER_LEFT
// #define MASTER_RIGHT #define MASTER_RIGHT
#define EE_HANDS // #define EE_HAND
#undef USE_I2C #undef USE_I2C
#undef SSD1306OLED #undef SSD1306OLED
#define USE_SERIAL_PD2
// #define TAPPING_FORCE_HOLD // #define TAPPING_FORCE_HOLD
// #define TAPPING_TERM 100 // #define TAPPING_TERM 100
@ -41,6 +38,10 @@
#endif #endif
#ifdef RGB_MATRIX_ENABLE #ifdef RGB_MATRIX_ENABLE
# ifdef CONVERT_TO_PROTON_C
# undef RGB_DI_PIN
# define RGB_DI_PIN PAL_LINE(GPIOA, 3)
# endif
# define RGB_MATRIX_KEYPRESSES // reacts to keypresses # define RGB_MATRIX_KEYPRESSES // reacts to keypresses
// # define RGB_MATRIX_KEYRELEASES // reacts to keyreleases (instead of keypresses) // # define RGB_MATRIX_KEYRELEASES // reacts to keyreleases (instead of keypresses)
// # define RGB_DISABLE_AFTER_TIMEOUT 0 // number of ticks to wait until disabling effects // # define RGB_DISABLE_AFTER_TIMEOUT 0 // number of ticks to wait until disabling effects
@ -54,6 +55,24 @@
# define RGB_MATRIX_SPD_STEP 10 # define RGB_MATRIX_SPD_STEP 10
#endif #endif
#ifdef CONVERT_TO_PROTON_C
# define WS2812_PWM_DRIVER PWMD15 // default: PWMD2
# define WS2812_PWM_CHANNEL 2 // default: 2
# define WS2812_PWM_PAL_MODE 9 // Pin "alternate function", see the respective datasheet for the appropriate values for your MCU. default: 2
# define WS2812_DMA_STREAM STM32_DMA1_STREAM5 // DMA Stream for TIMx_UP, see the respective reference manual for the appropriate values for your MCU.
# define WS2812_DMA_CHANNEL 5 // DMA Channel for TIMx_UP, see the respective reference manual for the appropriate values for your MCU.
# define WS2812_DMAMUX_ID STM32_DMAMUX1_TIM15_UP // DMAMUX configuration for TIMx_UP -- only required if your MCU has a DMAMUX peripheral, see the respective reference manual for the appropriate values for your MCU.
# undef SOFT_SERIAL_PIN
# define SOFT_SERIAL_PIN D3
# define SERIAL_USART_DRIVER SD1 // USART driver of TX pin. default: SD1
# define SERIAL_USART_TX_PAL_MODE 7 // Pin "alternate function", see the respective datasheet for the appropriate values for your MCU. default: 7
// #define INIT_EE_HANDS_LEFT
// #define INIT_EE_HANDS_RIGHT
#endif
#ifdef AUDIO_ENABLE #ifdef AUDIO_ENABLE
# define B6_AUDIO # define B6_AUDIO
# define NO_MUSIC_MODE # define NO_MUSIC_MODE
@ -64,8 +83,11 @@
#endif #endif
#undef PRODUCT #undef PRODUCT
#define PRODUCT Drashna Hacked Corne Keyboard #ifdef CONVERT_TO_PROTON_C
# define PRODUCT Drashna Hacked ARM Corne Keyboard
#else
# define PRODUCT Drashna Hacked Corne Keyboard
#endif
#define OLED_FONT_H "layouts/community/split_3x6_3/drashna/glcdfont.c" #define OLED_FONT_H "layouts/community/split_3x6_3/drashna/glcdfont.c"
// #define OLED_FONT_WIDTH 5 // #define OLED_FONT_WIDTH 5
// #define OLED_FONT_HEIGHT 7 // #define OLED_FONT_HEIGHT 7

22
layouts/community/split_3x6_3/drashna/halconf.h Normal file
View File

@ -0,0 +1,22 @@
/* Copyright 2020 Nick Brassel (tzarc)
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#pragma once
// #define HAL_USE_DAC TRUE
#define HAL_USE_PWM TRUE
#define HAL_USE_SERIAL TRUE
#include_next <halconf.h>

83
layouts/community/split_3x6_3/drashna/keymap.c
View File

@ -16,11 +16,6 @@
#include "drashna.h" #include "drashna.h"
#ifdef RGBLIGHT_ENABLE
// Following line allows macro to read current RGB settings
extern rgblight_config_t rgblight_config;
#endif
enum crkbd_keycodes { RGBRST = NEW_SAFE_RANGE }; enum crkbd_keycodes { RGBRST = NEW_SAFE_RANGE };
/* /*
@ -31,6 +26,7 @@ enum crkbd_keycodes { RGBRST = NEW_SAFE_RANGE };
* of use. K## is a placeholder to pass through the individual keycodes * of use. K## is a placeholder to pass through the individual keycodes
*/ */
// clang-format off
#define LAYOUT_split_3x6_3_base( \ #define LAYOUT_split_3x6_3_base( \
K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, \ K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, \
K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, \ K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, \
@ -40,7 +36,7 @@ enum crkbd_keycodes { RGBRST = NEW_SAFE_RANGE };
KC_ESC, K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, KC_MINS, \ KC_ESC, K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, KC_MINS, \
ALT_T(KC_TAB), K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, RALT_T(KC_QUOT), \ ALT_T(KC_TAB), K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, RALT_T(KC_QUOT), \
OS_LSFT, CTL_T(K21), K22, K23, K24, K25, K26, K27, K28, K29, RCTL_T(K2A), OS_RSFT, \ OS_LSFT, CTL_T(K21), K22, K23, K24, K25, K26, K27, K28, K29, RCTL_T(K2A), OS_RSFT, \
KC_GRV, KC_SPC, BK_LWER, DL_RAIS, KC_ENT, OS_RGUI \ RGB_MOD, KC_SPC, BK_LWER, DL_RAIS, KC_ENT, OS_RGUI \
) )
#define LAYOUT_split_3x6_3_base_wrapper(...) LAYOUT_split_3x6_3_base(__VA_ARGS__) #define LAYOUT_split_3x6_3_base_wrapper(...) LAYOUT_split_3x6_3_base(__VA_ARGS__)
@ -123,31 +119,17 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
}; };
// clang-format on // clang-format on
bool process_record_keymap(uint16_t keycode, keyrecord_t *record) {
if (record->event.pressed) {
#ifndef SPLIT_KEYBOARD
if (keycode == RESET && !is_master) {
return false;
}
#endif
}
return true;
}
#ifdef OLED_DRIVER_ENABLE #ifdef OLED_DRIVER_ENABLE
oled_rotation_t oled_init_user(oled_rotation_t rotation) { oled_rotation_t oled_init_user(oled_rotation_t rotation) {
# ifndef SPLIT_KEYBOARD if (is_keyboard_master()) {
if (is_master) {
# endif
return OLED_ROTATION_270; return OLED_ROTATION_270;
# ifndef SPLIT_KEYBOARD } else {
} else {
return rotation; return rotation;
} }
# endif
} }
#endif #endif
#ifdef TAPPING_TERM_PER_KEY
uint16_t get_tapping_term(uint16_t keycode, keyrecord_t *record) { uint16_t get_tapping_term(uint16_t keycode, keyrecord_t *record) {
switch (keycode) { switch (keycode) {
case ALT_T(KC_A): case ALT_T(KC_A):
@ -156,75 +138,74 @@ uint16_t get_tapping_term(uint16_t keycode, keyrecord_t *record) {
return TAPPING_TERM; return TAPPING_TERM;
} }
} }
#endif
void matrix_slave_scan_user(void) {
#ifdef RGB_MATRIX_ENABLE
rgb_matrix_task();
#endif
}
#ifdef RGB_MATRIX_ENABLE #ifdef RGB_MATRIX_ENABLE
void suspend_power_down_keymap(void) { rgb_matrix_set_suspend_state(true); } void suspend_power_down_keymap(void) { rgb_matrix_set_suspend_state(true); }
void suspend_wakeup_init_keymap(void) { rgb_matrix_set_suspend_state(false); } void suspend_wakeup_init_keymap(void) { rgb_matrix_set_suspend_state(false); }
void check_default_layer(uint8_t mode, uint8_t type) { void check_default_layer(uint8_t mode, uint8_t type, uint8_t led_min, uint8_t led_max) {
switch (get_highest_layer(default_layer_state)) { switch (get_highest_layer(default_layer_state)) {
case _QWERTY: case _QWERTY:
rgb_matrix_layer_helper(HSV_CYAN, mode, rgb_matrix_config.speed, type); rgb_matrix_layer_helper(HSV_CYAN, mode, rgb_matrix_config.speed, type, led_min, led_max);
break; break;
case _COLEMAK: case _COLEMAK:
rgb_matrix_layer_helper(HSV_MAGENTA, mode, rgb_matrix_config.speed, type); rgb_matrix_layer_helper(HSV_MAGENTA, mode, rgb_matrix_config.speed, type, led_min, led_max);
break; break;
case _DVORAK: case _DVORAK:
rgb_matrix_layer_helper(HSV_SPRINGGREEN, mode, rgb_matrix_config.speed, type); rgb_matrix_layer_helper(HSV_SPRINGGREEN, mode, rgb_matrix_config.speed, type, led_min, led_max);
break; break;
case _WORKMAN: case _WORKMAN:
rgb_matrix_layer_helper(HSV_GOLDENROD, mode, rgb_matrix_config.speed, type); rgb_matrix_layer_helper(HSV_GOLDENROD, mode, rgb_matrix_config.speed, type, led_min, led_max);
break; break;
case _NORMAN: case _NORMAN:
rgb_matrix_layer_helper(HSV_CORAL, mode, rgb_matrix_config.speed, type); rgb_matrix_layer_helper(HSV_CORAL, mode, rgb_matrix_config.speed, type, led_min, led_max);
break; break;
case _MALTRON: case _MALTRON:
rgb_matrix_layer_helper(HSV_YELLOW, mode, rgb_matrix_config.speed, type); rgb_matrix_layer_helper(HSV_YELLOW, mode, rgb_matrix_config.speed, type, led_min, led_max);
break; break;
case _EUCALYN: case _EUCALYN:
rgb_matrix_layer_helper(HSV_PINK, mode, rgb_matrix_config.speed, type); rgb_matrix_layer_helper(HSV_PINK, mode, rgb_matrix_config.speed, type, led_min, led_max);
break; break;
case _CARPLAX: case _CARPLAX:
rgb_matrix_layer_helper(HSV_BLUE, mode, rgb_matrix_config.speed, type); rgb_matrix_layer_helper(HSV_BLUE, mode, rgb_matrix_config.speed, type, led_min, led_max);
break; break;
} }
} }
void rgb_matrix_indicators_user(void) { void rgb_matrix_indicators_advanced_user(uint8_t led_min, uint8_t led_max) {
if (userspace_config.rgb_layer_change && if (!is_keyboard_master()) return;
# ifdef RGB_DISABLE_WHEN_USB_SUSPENDED if (userspace_config.rgb_layer_change) {
!g_suspend_state &&
# endif
# if defined(RGBLIGHT_ENABLE)
(!rgblight_config.enable && rgb_matrix_config.enable)
# else
rgb_matrix_config.enable
# endif
) {
switch (get_highest_layer(layer_state)) { switch (get_highest_layer(layer_state)) {
case _GAMEPAD: case _GAMEPAD:
rgb_matrix_layer_helper(HSV_ORANGE, 0, rgb_matrix_config.speed, LED_FLAG_UNDERGLOW); rgb_matrix_layer_helper(HSV_ORANGE, 0, rgb_matrix_config.speed, LED_FLAG_UNDERGLOW, led_min, led_max);
break; break;
case _DIABLO: case _DIABLO:
rgb_matrix_layer_helper(HSV_RED, 0, rgb_matrix_config.speed, LED_FLAG_UNDERGLOW); rgb_matrix_layer_helper(HSV_RED, 0, rgb_matrix_config.speed, LED_FLAG_UNDERGLOW, led_min, led_max);
break; break;
case _RAISE: case _RAISE:
rgb_matrix_layer_helper(HSV_YELLOW, 0, rgb_matrix_config.speed, LED_FLAG_UNDERGLOW); rgb_matrix_layer_helper(HSV_YELLOW, 0, rgb_matrix_config.speed, LED_FLAG_UNDERGLOW, led_min, led_max);
break; break;
case _LOWER: case _LOWER:
rgb_matrix_layer_helper(HSV_GREEN, 0, rgb_matrix_config.speed, LED_FLAG_UNDERGLOW); rgb_matrix_layer_helper(HSV_GREEN, 0, rgb_matrix_config.speed, LED_FLAG_UNDERGLOW, led_min, led_max);
break; break;
case _ADJUST: case _ADJUST:
rgb_matrix_layer_helper(HSV_RED, 0, rgb_matrix_config.speed, LED_FLAG_UNDERGLOW); rgb_matrix_layer_helper(HSV_RED, 0, rgb_matrix_config.speed, LED_FLAG_UNDERGLOW, led_min, led_max);
break; break;
default: { default: {
check_default_layer(IS_LAYER_ON(_MODS), LED_FLAG_UNDERGLOW); check_default_layer(IS_LAYER_ON(_MODS), LED_FLAG_UNDERGLOW, led_min, led_max);
break; break;
} }
} }
check_default_layer(0, LED_FLAG_MODIFIER); check_default_layer(0, LED_FLAG_MODIFIER, led_min, led_max);
} }
} }
#endif #endif

32
layouts/community/split_3x6_3/drashna/mcuconf.h Normal file
View File

@ -0,0 +1,32 @@
/* Copyright 2020 Nick Brassel (tzarc)
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#pragma once
#include_next <mcuconf.h>
// #undef STM32_HSE_ENABLED
// #define STM32_HSE_ENABLED FALSE
#undef STM32_GPT_USE_TIM15
#define STM32_GPT_USE_TIM15 FALSE
#undef STM32_PWM_USE_TIM15
#define STM32_PWM_USE_TIM15 TRUE
#undef STM32_SERIAL_USE_USART1
#define STM32_SERIAL_USE_USART1 TRUE
#undef STM32_PWM_TIM15_IRQ_PRIORITY
#define STM32_PWM_TIM15_IRQ_PRIORITY 16

10
layouts/community/split_3x6_3/drashna/rules.mk
View File

@ -3,7 +3,7 @@
# change to "no" to disable the options, or define them in the Makefile in # change to "no" to disable the options, or define them in the Makefile in
# the appropriate keymap folder that will get included automatically # the appropriate keymap folder that will get included automatically
# #
BOOTMAGIC_ENABLE = no # Virtual DIP switch configuration(+1000) BOOTMAGIC_ENABLE = lite # Virtual DIP switch configuration(+1000)
MOUSEKEY_ENABLE = no # Mouse keys(+4700) MOUSEKEY_ENABLE = no # Mouse keys(+4700)
EXTRAKEY_ENABLE = yes # Audio control and System control(+450) EXTRAKEY_ENABLE = yes # Audio control and System control(+450)
CONSOLE_ENABLE = no # Console for debug(+400) CONSOLE_ENABLE = no # Console for debug(+400)
@ -20,9 +20,15 @@ SWAP_HANDS_ENABLE = no # Enable one-hand typing
# Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE # Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
SLEEP_LED_ENABLE = no # Breathing sleep LED during USB suspend SLEEP_LED_ENABLE = no # Breathing sleep LED during USB suspend
ifeq ($(strip $(KEYBOARD)), crkbd/rev1) ifeq ($(strip $(KEYBOARD)), crkbd/rev1/common)
OLED_DRIVER_ENABLE = yes OLED_DRIVER_ENABLE = yes
RGB_MATRIX_ENABLE = yes RGB_MATRIX_ENABLE = yes
HAPTIC_ENABLE = SOLENOID HAPTIC_ENABLE = SOLENOID
BOOTLOADER = qmk-dfu BOOTLOADER = qmk-dfu
endif endif
ifeq ($(strip $(CTPC)), yes)
HAPTIC_ENABLE = no
WS2812_DRIVER = pwm
SERIAL_DRIVER = usart
endif

0
layouts/community/split_3x6_3/drashna/ssd1306.c Normal file
View File

16
users/drashna/config.h
View File

@ -22,6 +22,10 @@
/* Set Polling rate to 1000Hz */ /* Set Polling rate to 1000Hz */
#define USB_POLLING_INTERVAL_MS 1 #define USB_POLLING_INTERVAL_MS 1
#if defined(SPLIT_KEYBOAD)
# define SPLIT_MODS_ENABLE
#endif
#ifdef AUDIO_ENABLE #ifdef AUDIO_ENABLE
# define AUDIO_CLICKY # define AUDIO_CLICKY
@ -40,9 +44,9 @@
#endif // !AUDIO_ENABLE #endif // !AUDIO_ENABLE
#ifdef RGBLIGHT_ENABLE #ifdef RGBLIGHT_ENABLE
# undef RGBLIGHT_ANIMATIONS # define RGBLIGHT_SLEEP
# if defined(__AVR__) && !defined(__AVR_AT90USB1286__) # if defined(__AVR__) && !defined(__AVR_AT90USB1286__)
# define RGBLIGHT_SLEEP # undef RGBLIGHT_ANIMATIONS
# define RGBLIGHT_EFFECT_BREATHING # define RGBLIGHT_EFFECT_BREATHING
# define RGBLIGHT_EFFECT_SNAKE # define RGBLIGHT_EFFECT_SNAKE
# define RGBLIGHT_EFFECT_KNIGHT # define RGBLIGHT_EFFECT_KNIGHT
@ -101,6 +105,14 @@
# endif // AVR # endif // AVR
#endif // RGB_MATRIX_ENABLE #endif // RGB_MATRIX_ENABLE
#ifdef OLED_DRIVER_ENABLE
# ifdef SPLIT_KEYBOARD
# define OLED_UPDATE_INTERVAL 60
# else
# define OLED_UPDATE_INTERVAL 15
# endif
#endif
#ifndef ONESHOT_TAP_TOGGLE #ifndef ONESHOT_TAP_TOGGLE
# define ONESHOT_TAP_TOGGLE 2 # define ONESHOT_TAP_TOGGLE 2
#endif // !ONESHOT_TAP_TOGGLE #endif // !ONESHOT_TAP_TOGGLE

28
users/drashna/drashna.c
View File

@ -49,21 +49,6 @@ bool mod_key_press(uint16_t code, uint16_t mod_code, bool pressed, uint16_t this
return false; return false;
} }
void bootmagic_lite(void) {
matrix_scan();
#if defined(DEBOUNCING_DELAY) && DEBOUNCING_DELAY > 0
wait_ms(DEBOUNCING_DELAY * 2);
#elif defined(DEBOUNCE) && DEBOUNCE > 0
wait_ms(DEBOUNCE * 2);
#else
wait_ms(30);
#endif
matrix_scan();
if (matrix_get_row(BOOTMAGIC_LITE_ROW) & (1 << BOOTMAGIC_LITE_COLUMN)) {
bootloader_jump();
}
}
__attribute__((weak)) void keyboard_pre_init_keymap(void) {} __attribute__((weak)) void keyboard_pre_init_keymap(void) {}
void keyboard_pre_init_user(void) { void keyboard_pre_init_user(void) {
@ -75,6 +60,7 @@ void keyboard_pre_init_user(void) {
// customization of the keymap. Use _keymap instead of _user // customization of the keymap. Use _keymap instead of _user
// functions in the keymaps // functions in the keymaps
__attribute__((weak)) void matrix_init_keymap(void) {} __attribute__((weak)) void matrix_init_keymap(void) {}
__attribute__((weak)) void matrix_init_secret(void) {}
// Call user matrix init, set default RGB colors and then // Call user matrix init, set default RGB colors and then
// call the keymap's init function // call the keymap's init function
@ -86,6 +72,8 @@ void matrix_init_user(void) {
DDRB &= ~(1 << 0); DDRB &= ~(1 << 0);
PORTB &= ~(1 << 0); PORTB &= ~(1 << 0);
#endif #endif
matrix_init_secret();
matrix_init_keymap(); matrix_init_keymap();
} }
@ -103,7 +91,9 @@ void keyboard_post_init_user(void) {
__attribute__((weak)) void shutdown_keymap(void) {} __attribute__((weak)) void shutdown_keymap(void) {}
#ifdef RGB_MATRIX_ENABLE
void rgb_matrix_update_pwm_buffers(void); void rgb_matrix_update_pwm_buffers(void);
#endif
void shutdown_user(void) { void shutdown_user(void) {
#ifdef RGBLIGHT_ENABLE #ifdef RGBLIGHT_ENABLE
@ -129,6 +119,8 @@ void suspend_wakeup_init_user(void) { suspend_wakeup_init_keymap(); }
__attribute__((weak)) void matrix_scan_keymap(void) {} __attribute__((weak)) void matrix_scan_keymap(void) {}
__attribute__((weak)) void matrix_scan_secret(void) {}
// No global matrix scan code, so just run keymap's matrix // No global matrix scan code, so just run keymap's matrix
// scan function // scan function
void matrix_scan_user(void) { void matrix_scan_user(void) {
@ -149,6 +141,8 @@ void matrix_scan_user(void) {
matrix_scan_rgb_matrix(); matrix_scan_rgb_matrix();
#endif #endif
matrix_scan_secret();
matrix_scan_keymap(); matrix_scan_keymap();
} }
@ -157,6 +151,8 @@ __attribute__((weak)) layer_state_t layer_state_set_keymap(layer_state_t state)
// on layer change, no matter where the change was initiated // on layer change, no matter where the change was initiated
// Then runs keymap's layer change check // Then runs keymap's layer change check
layer_state_t layer_state_set_user(layer_state_t state) { layer_state_t layer_state_set_user(layer_state_t state) {
if (!is_keyboard_master()) { return state; }
state = update_tri_layer_state(state, _RAISE, _LOWER, _ADJUST); state = update_tri_layer_state(state, _RAISE, _LOWER, _ADJUST);
#if defined(RGBLIGHT_ENABLE) #if defined(RGBLIGHT_ENABLE)
state = layer_state_set_rgb_light(state); state = layer_state_set_rgb_light(state);
@ -168,6 +164,8 @@ __attribute__((weak)) layer_state_t default_layer_state_set_keymap(layer_state_t
// Runs state check and changes underglow color and animation // Runs state check and changes underglow color and animation
layer_state_t default_layer_state_set_user(layer_state_t state) { layer_state_t default_layer_state_set_user(layer_state_t state) {
if (!is_keyboard_master()) { return state; }
state = default_layer_state_set_keymap(state); state = default_layer_state_set_keymap(state);
#if 0 #if 0
# if defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE) # if defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE)

5
users/drashna/drashna.h
View File

@ -17,7 +17,6 @@
#pragma once #pragma once
#include QMK_KEYBOARD_H #include QMK_KEYBOARD_H
#include "version.h"
#include "eeprom.h" #include "eeprom.h"
#include "wrappers.h" #include "wrappers.h"
#include "process_records.h" #include "process_records.h"
@ -58,13 +57,17 @@ enum userspace_layers {
_ADJUST, _ADJUST,
}; };
#define _MOUSE _MACROS
bool mod_key_press_timer(uint16_t code, uint16_t mod_code, bool pressed); bool mod_key_press_timer(uint16_t code, uint16_t mod_code, bool pressed);
bool mod_key_press(uint16_t code, uint16_t mod_code, bool pressed, uint16_t this_timer); bool mod_key_press(uint16_t code, uint16_t mod_code, bool pressed, uint16_t this_timer);
void matrix_init_keymap(void); void matrix_init_keymap(void);
void matrix_init_secret(void);
void shutdown_keymap(void); void shutdown_keymap(void);
void suspend_power_down_keymap(void); void suspend_power_down_keymap(void);
void suspend_wakeup_init_keymap(void); void suspend_wakeup_init_keymap(void);
void matrix_scan_keymap(void); void matrix_scan_keymap(void);
void matrix_scan_secret(void);
layer_state_t layer_state_set_keymap(layer_state_t state); layer_state_t layer_state_set_keymap(layer_state_t state);
layer_state_t default_layer_state_set_keymap(layer_state_t state); layer_state_t default_layer_state_set_keymap(layer_state_t state);
void led_set_keymap(uint8_t usb_led); void led_set_keymap(uint8_t usb_led);

31
users/drashna/oled_stuff.c
View File

@ -16,8 +16,6 @@
#include "drashna.h" #include "drashna.h"
extern uint8_t is_master;
#ifndef KEYLOGGER_LENGTH #ifndef KEYLOGGER_LENGTH
// # ifdef OLED_DISPLAY_128X64 // # ifdef OLED_DISPLAY_128X64
# define KEYLOGGER_LENGTH ((int)(OLED_DISPLAY_HEIGHT / OLED_FONT_WIDTH)) # define KEYLOGGER_LENGTH ((int)(OLED_DISPLAY_HEIGHT / OLED_FONT_WIDTH))
@ -187,11 +185,11 @@ void render_bootmagic_status(void) {
}; };
bool is_bootmagic_on; bool is_bootmagic_on;
#ifdef OLED_DISPLAY_128X64 #ifdef OLED_DISPLAY_128X64
is_bootmagic_on = !keymap_config.swap_lctl_lgui; is_bootmagic_on = !keymap_config.swap_lctl_lgui;
#else #else
is_bootmagic_on = keymap_config.swap_lctl_lgui; is_bootmagic_on = keymap_config.swap_lctl_lgui;
#endif #endif
oled_write_P(PSTR(OLED_RENDER_BOOTMAGIC_NAME), false); oled_write_P(PSTR(OLED_RENDER_BOOTMAGIC_NAME), false);
#ifdef OLED_DISPLAY_128X64 #ifdef OLED_DISPLAY_128X64
@ -259,21 +257,20 @@ void render_status_secondary(void) {
#if !defined(SPLIT_TRANSPORT_MIRROR) || defined(OLED_DISPLAY_128X64) #if !defined(SPLIT_TRANSPORT_MIRROR) || defined(OLED_DISPLAY_128X64)
oled_driver_render_logo(); oled_driver_render_logo();
#endif #endif
#ifdef SPLIT_TRANSPORT_MIRROR
/* Show Keyboard Layout */ /* Show Keyboard Layout */
render_default_layer_state(); render_default_layer_state();
render_layer_state(); render_layer_state();
render_mod_status(get_mods() | get_oneshot_mods()); render_mod_status(get_mods() | get_oneshot_mods());
render_keylogger_status(); render_keylogger_status();
#endif
} }
// clang-format on // clang-format on
void render_status_main(void) { void render_status_main(void) {
oled_driver_render_logo();
/* Show Keyboard Layout */ /* Show Keyboard Layout */
render_default_layer_state(); render_default_layer_state();
render_keylock_status(host_keyboard_leds()); // render_keylock_status(host_keyboard_leds());
render_bootmagic_status(); render_bootmagic_status();
render_user_status(); render_user_status();
@ -281,19 +278,15 @@ void render_status_main(void) {
} }
void oled_task_user(void) { void oled_task_user(void) {
if (timer_elapsed32(oled_timer) > 30000) {
oled_off();
return;
}
#ifndef SPLIT_KEYBOARD
else {
oled_on();
}
#endif
update_log(); update_log();
if (is_master) { if (is_keyboard_master()) {
if (timer_elapsed32(oled_timer) > 30000) {
oled_off();
return;
} else {
oled_on();
}
render_status_main(); // Renders the current keyboard state (layer, lock, caps, scroll, etc) render_status_main(); // Renders the current keyboard state (layer, lock, caps, scroll, etc)
} else { } else {
render_status_secondary(); render_status_secondary();

7
users/drashna/process_records.c
View File

@ -15,6 +15,7 @@
*/ */
#include "drashna.h" #include "drashna.h"
#include "version.h"
uint16_t copy_paste_timer; uint16_t copy_paste_timer;
@ -27,11 +28,7 @@ __attribute__((weak)) bool process_record_secrets(uint16_t keycode, keyrecord_t
bool process_record_user(uint16_t keycode, keyrecord_t *record) { bool process_record_user(uint16_t keycode, keyrecord_t *record) {
// If console is enabled, it will print the matrix position and status of each key pressed // If console is enabled, it will print the matrix position and status of each key pressed
#ifdef KEYLOGGER_ENABLE #ifdef KEYLOGGER_ENABLE
# if defined(KEYBOARD_ergodox_ez) || defined(KEYBOARD_keebio_iris_rev2) uprintf("KL: kc: 0x%04X, col: %2u, row: %2u, pressed: %b, time: %5u, int: %b, count: %u\n", keycode, record->event.key.col, record->event.key.row, record->event.pressed, record->event.time, record->tap.interrupted, record->tap.count);
xprintf("KL: kc: %u, col: %u, row: %u, pressed: %u\n", keycode, record->event.key.row, record->event.key.col, record->event.pressed);
# else
xprintf("KL: kc: %u, col: %u, row: %u, pressed: %u\n", keycode, record->event.key.col, record->event.key.row, record->event.pressed);
# endif
#endif // KEYLOGGER_ENABLE #endif // KEYLOGGER_ENABLE
#ifdef OLED_DRIVER_ENABLE #ifdef OLED_DRIVER_ENABLE
process_record_user_oled(keycode, record); process_record_user_oled(keycode, record);

2
users/drashna/process_records.h
View File

@ -17,7 +17,7 @@
#pragma once #pragma once
#include "drashna.h" #include "drashna.h"
#if defined(KEYMAP_SAFE_RANGE) #if defined(KEYBOARD_handwired_dactyl_manuform_5x6_right_trackball)
# define PLACEHOLDER_SAFE_RANGE KEYMAP_SAFE_RANGE # define PLACEHOLDER_SAFE_RANGE KEYMAP_SAFE_RANGE
#else #else
# define PLACEHOLDER_SAFE_RANGE SAFE_RANGE # define PLACEHOLDER_SAFE_RANGE SAFE_RANGE

6
users/drashna/rgb_matrix_stuff.c
View File

@ -26,7 +26,7 @@ static uint32_t hypno_timer;
# define RGB_MATRIX_REST_MODE RGB_MATRIX_CYCLE_OUT_IN # define RGB_MATRIX_REST_MODE RGB_MATRIX_CYCLE_OUT_IN
#endif #endif
void rgb_matrix_layer_helper(uint8_t hue, uint8_t sat, uint8_t val, uint8_t mode, uint8_t speed, uint8_t led_type) { void rgb_matrix_layer_helper(uint8_t hue, uint8_t sat, uint8_t val, uint8_t mode, uint8_t speed, uint8_t led_type, uint8_t led_min, uint8_t led_max) {
HSV hsv = {hue, sat, val}; HSV hsv = {hue, sat, val};
if (hsv.v > rgb_matrix_get_val()) { if (hsv.v > rgb_matrix_get_val()) {
hsv.v = rgb_matrix_get_val(); hsv.v = rgb_matrix_get_val();
@ -40,7 +40,7 @@ void rgb_matrix_layer_helper(uint8_t hue, uint8_t sat, uint8_t val, uint8_t mode
RGB rgb = hsv_to_rgb(hsv); RGB rgb = hsv_to_rgb(hsv);
for (uint8_t i = 0; i < DRIVER_LED_TOTAL; i++) { for (uint8_t i = 0; i < DRIVER_LED_TOTAL; i++) {
if (HAS_FLAGS(g_led_config.flags[i], led_type)) { if (HAS_FLAGS(g_led_config.flags[i], led_type)) {
rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b); RGB_MATRIX_INDICATOR_SET_COLOR(i, rgb.r, rgb.g, rgb.b);
} }
} }
break; break;
@ -50,7 +50,7 @@ void rgb_matrix_layer_helper(uint8_t hue, uint8_t sat, uint8_t val, uint8_t mode
RGB rgb = hsv_to_rgb(hsv); RGB rgb = hsv_to_rgb(hsv);
for (uint8_t i = 0; i < DRIVER_LED_TOTAL; i++) { for (uint8_t i = 0; i < DRIVER_LED_TOTAL; i++) {
if (HAS_FLAGS(g_led_config.flags[i], led_type)) { if (HAS_FLAGS(g_led_config.flags[i], led_type)) {
rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b); RGB_MATRIX_INDICATOR_SET_COLOR(i, rgb.r, rgb.g, rgb.b);
} }
} }
break; break;

2
users/drashna/rgb_matrix_stuff.h
View File

@ -22,4 +22,4 @@ void keyboard_post_init_rgb_matrix(void);
void matrix_scan_rgb_matrix(void); void matrix_scan_rgb_matrix(void);
void rgb_matrix_set_color_all(uint8_t red, uint8_t green, uint8_t blue); void rgb_matrix_set_color_all(uint8_t red, uint8_t green, uint8_t blue);
void rgb_matrix_layer_helper(uint8_t hue, uint8_t sat, uint8_t val, uint8_t mode, uint8_t speed, uint8_t led_type); void rgb_matrix_layer_helper(uint8_t hue, uint8_t sat, uint8_t val, uint8_t mode, uint8_t speed, uint8_t led_type, uint8_t led_min, uint8_t led_max);

6
users/drashna/rgb_stuff.c
View File

@ -178,7 +178,11 @@ layer_state_t layer_state_set_rgb_light(layer_state_t state) {
uint8_t mode = layer_state_cmp(state,_MODS) ? RGBLIGHT_MODE_BREATHING : RGBLIGHT_MODE_STATIC_LIGHT; uint8_t mode = layer_state_cmp(state,_MODS) ? RGBLIGHT_MODE_BREATHING : RGBLIGHT_MODE_STATIC_LIGHT;
switch (get_highest_layer(state|default_layer_state)) { switch (get_highest_layer(state|default_layer_state)) {
case _MACROS: case _MACROS:
rgblight_set_hsv_and_mode(HSV_ORANGE, userspace_config.is_overwatch ? RGBLIGHT_MODE_SNAKE + 2 : RGBLIGHT_MODE_SNAKE + 3); # ifdef RGBLIGHT_EFFECT_TWINKLE
rgblight_set_hsv_and_mode(HSV_CHARTREUSE, RGBLIGHT_MODE_TWINKLE + 5);
# else
rgblight_set_hsv_and_mode(HSV_CHARTREUSE, RGBLIGHT_MODE_BREATHING + 3);
# endif
break; break;
case _MEDIA: case _MEDIA:
rgblight_set_hsv_and_mode(HSV_CHARTREUSE, RGBLIGHT_MODE_KNIGHT + 1); rgblight_set_hsv_and_mode(HSV_CHARTREUSE, RGBLIGHT_MODE_KNIGHT + 1);

9
users/drashna/wrappers.h
View File

@ -162,6 +162,15 @@ NOTE: These are all the same length. If you do a search/replace
#define _________________WHITE_L3__________________ KC_X, KC_R, KC_F, KC_DOT, KC_Z #define _________________WHITE_L3__________________ KC_X, KC_R, KC_F, KC_DOT, KC_Z
#define _________________HALMAK_L1_________________ KC_W, KC_L, KC_R, KC_B, KC_Z
#define _________________HALMAK_L2_________________ KC_S, KC_H, KC_N, KC_T, KC_COMM
#define _________________HALMAK_L3_________________ KC_F, KC_M, KC_V, KC_V, KC_SLASH
#define _________________HALMAK_R1_________________ KC_SCLN, KC_Q, KC_U, KC_D, KC_J
#define _________________HALMAK_R2_________________ KC_DOT, KC_A, KC_E, KC_O, KC_I
#define _________________HALMAK_R3_________________ KC_G, KC_P, KC_X, KC_K, KC_Y
#define ________________NUMBER_LEFT________________ KC_1, KC_2, KC_3, KC_4, KC_5 #define ________________NUMBER_LEFT________________ KC_1, KC_2, KC_3, KC_4, KC_5
#define ________________NUMBER_RIGHT_______________ KC_6, KC_7, KC_8, KC_9, KC_0 #define ________________NUMBER_RIGHT_______________ KC_6, KC_7, KC_8, KC_9, KC_0
#define _________________FUNC_LEFT_________________ KC_F1, KC_F2, KC_F3, KC_F4, KC_F5 #define _________________FUNC_LEFT_________________ KC_F1, KC_F2, KC_F3, KC_F4, KC_F5