diff options
Diffstat (limited to 'quantum')
| -rw-r--r-- | quantum/dynamic_macro.h | 9 | ||||
| -rw-r--r-- | quantum/keymap.h | 13 | ||||
| -rw-r--r-- | quantum/keymap_extras/keymap_dvp.h | 82 | ||||
| -rw-r--r-- | quantum/matrix.c | 333 | ||||
| -rw-r--r-- | quantum/process_keycode/process_midi.c | 4 | ||||
| -rw-r--r-- | quantum/process_keycode/process_unicode.c | 52 | ||||
| -rw-r--r-- | quantum/process_keycode/process_unicode.h | 13 | ||||
| -rw-r--r-- | quantum/quantum.c | 3 | ||||
| -rw-r--r-- | quantum/rgblight.c | 61 | ||||
| -rw-r--r-- | quantum/rgblight.h | 6 |
10 files changed, 439 insertions, 137 deletions
diff --git a/quantum/dynamic_macro.h b/quantum/dynamic_macro.h index a3ad61bc7..e6dbc5b9c 100644 --- a/quantum/dynamic_macro.h +++ b/quantum/dynamic_macro.h @@ -8,8 +8,13 @@ /* May be overridden with a custom value. Be aware that the effective * macro length is half of this value: each keypress is recorded twice * because of the down-event and up-event. This is not a bug, it's the - * intended behavior. */ -#define DYNAMIC_MACRO_SIZE 256 + * intended behavior. + * + * Usually it should be fine to set the macro size to at least 256 but + * there have been reports of it being too much in some users' cases, + * so 128 is considered a safe default. + */ +#define DYNAMIC_MACRO_SIZE 128 #endif /* DYNAMIC_MACRO_RANGE must be set as the last element of user's diff --git a/quantum/keymap.h b/quantum/keymap.h index 98ddfd0c5..a01bbfbd1 100644 --- a/quantum/keymap.h +++ b/quantum/keymap.h @@ -84,6 +84,10 @@ enum quantum_keycodes { QK_MOD_TAP_MAX = 0x6FFF, QK_TAP_DANCE = 0x7100, QK_TAP_DANCE_MAX = 0x71FF, +#ifdef UNICODEMAP_ENABLE + QK_UNICODE_MAP = 0x7800, + QK_UNICODE_MAP_MAX = 0x7FFF, +#endif #ifdef UNICODE_ENABLE QK_UNICODE = 0x8000, QK_UNICODE_MAX = 0xFFFF, @@ -191,6 +195,7 @@ enum quantum_keycodes { #define HYPR(kc) (kc | QK_LCTL | QK_LSFT | QK_LALT | QK_LGUI) #define MEH(kc) (kc | QK_LCTL | QK_LSFT | QK_LALT) #define LCAG(kc) (kc | QK_LCTL | QK_LALT | QK_LGUI) +#define ALTG(kc) (kc | QK_RCTL | QK_RALT) #define MOD_HYPR 0xf #define MOD_MEH 0x7 @@ -295,7 +300,10 @@ enum quantum_keycodes { // ON_PRESS = 1 // ON_RELEASE = 2 // Unless you have a good reason not to do so, prefer ON_PRESS (1) as your default. -#define TO(layer, when) (layer | QK_TO | (when << 0x4)) +// In fact, we changed it to assume ON_PRESS for sanity/simplicity. If needed, you can add your own +// keycode modeled after the old version, kept below for this. +/* #define TO(layer, when) (layer | QK_TO | (when << 0x4)) */ +#define TO(layer) (layer | QK_TO | (ON_PRESS << 0x4)) // Momentary switch layer - 256 layer max #define MO(layer) (layer | QK_MOMENTARY) @@ -335,5 +343,8 @@ enum quantum_keycodes { #define UC(n) UNICODE(n) #endif +#ifdef UNICODEMAP_ENABLE + #define X(n) (n | QK_UNICODE_MAP) +#endif #endif diff --git a/quantum/keymap_extras/keymap_dvp.h b/quantum/keymap_extras/keymap_dvp.h new file mode 100644 index 000000000..83f49a52b --- /dev/null +++ b/quantum/keymap_extras/keymap_dvp.h @@ -0,0 +1,82 @@ +#ifndef KEYMAP_DVP_H +#define KEYMAP_DVP_H + +#include "keymap.h" + +// Normal characters +#define DP_DLR KC_GRV +#define DP_AMPR KC_1 +#define DP_LBRC KC_2 +#define DP_LCBR KC_3 +#define DP_RCBR KC_4 +#define DP_LPRN KC_5 +#define DP_EQL KC_6 +#define DP_ASTR KC_7 +#define DP_RPRN KC_8 +#define DP_PLUS KC_9 +#define DP_RBRC KC_0 +#define DP_EXLM KC_MINS +#define DP_HASH KC_EQL + +#define DP_SCLN KC_Q +#define DP_COMM KC_W +#define DP_DOT KC_E +#define DP_P KC_R +#define DP_Y KC_T +#define DP_F KC_Y +#define DP_G KC_U +#define DP_C KC_I +#define DP_R KC_O +#define DP_L KC_P +#define DP_SLSH KC_LBRC +#define DP_AT KC_RBRC +#define DP_BSLS KC_BSLS + +#define DP_A KC_A +#define DP_O KC_S +#define DP_E KC_D +#define DP_U KC_F +#define DP_I KC_G +#define DP_D KC_H +#define DP_H KC_J +#define DP_T KC_K +#define DP_N KC_L +#define DP_S KC_SCLN +#define DP_MINS KC_QUOT + +#define DP_QUOT KC_Z +#define DP_Q KC_X +#define DP_J KC_C +#define DP_K KC_V +#define DP_X KC_B +#define DP_B KC_N +#define DP_M KC_M +#define DP_W KC_COMM +#define DP_V KC_DOT +#define DP_Z KC_SLSH + +// Shifted characters +#define DP_TILD LSFT(DP_DLR) +#define DP_PERC LSFT(DP_AMPR) +#define DP_7 LSFT(DP_LBRC) +#define DP_5 LSFT(DP_LCBR) +#define DP_3 LSFT(DP_RCBR) +#define DP_1 LSFT(DP_LPRN) +#define DP_9 LSFT(DP_EQL) +#define DP_0 LSFT(DP_ASTR) +#define DP_2 LSFT(DP_RPRN) +#define DP_4 LSFT(DP_PLUS) +#define DP_6 LSFT(DP_RBRC) +#define DP_8 LSFT(DP_EXLM) +#define DP_GRV LSFT(DP_HASH) + +#define DP_COLN LSFT(DP_SCLN) +#define DP_LABK LSFT(DP_COMM) +#define DP_RABK LSFT(DP_DOT) +#define DP_QUES LSFT(DP_SLSH) +#define DP_CIRC LSFT(DP_AT) +#define DP_PIPE LSFT(DP_BSLS) +#define DP_UNDS LSFT(DP_MINS) +#define DP_DQUO LSFT(DP_QUOT) + +#endif diff --git a/quantum/matrix.c b/quantum/matrix.c index 3174e0739..f45b251e4 100644 --- a/quantum/matrix.c +++ b/quantum/matrix.c @@ -26,6 +26,27 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. #include "util.h" #include "matrix.h" +#if (MATRIX_COLS <= 8) +# define print_matrix_header() print("\nr/c 01234567\n") +# define print_matrix_row(row) print_bin_reverse8(matrix_get_row(row)) +# define matrix_bitpop(i) bitpop(matrix[i]) +# define ROW_SHIFTER ((uint8_t)1) +#elif (MATRIX_COLS <= 16) +# define print_matrix_header() print("\nr/c 0123456789ABCDEF\n") +# define print_matrix_row(row) print_bin_reverse16(matrix_get_row(row)) +# define matrix_bitpop(i) bitpop16(matrix[i]) +# define ROW_SHIFTER ((uint16_t)1) +#elif (MATRIX_COLS <= 32) +# define print_matrix_header() print("\nr/c 0123456789ABCDEF0123456789ABCDEF\n") +# define print_matrix_row(row) print_bin_reverse32(matrix_get_row(row)) +# define matrix_bitpop(i) bitpop32(matrix[i]) +# define ROW_SHIFTER ((uint32_t)1) +#endif + +#ifdef MATRIX_MASKED +extern const matrix_row_t matrix_mask[]; +#endif + /* Set 0 if debouncing isn't needed */ #ifndef DEBOUNCING_DELAY @@ -38,24 +59,25 @@ static const uint8_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS; /* matrix state(1:on, 0:off) */ static matrix_row_t matrix[MATRIX_ROWS]; + +static matrix_row_t matrix_raw[MATRIX_ROWS]; static matrix_row_t matrix_debouncing[MATRIX_ROWS]; -#if DIODE_DIRECTION == ROW2COL - static matrix_row_t matrix_reversed[MATRIX_COLS]; - static matrix_row_t matrix_reversed_debouncing[MATRIX_COLS]; -#endif -#if MATRIX_COLS > 16 - #define SHIFTER 1UL -#else - #define SHIFTER 1 +#if (DIODE_DIRECTION == COL2ROW) + static void init_cols(void); + static void read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row); + static void unselect_rows(void); + static void select_row(uint8_t row); + static void unselect_row(uint8_t row); +#else // ROW2COL + static void init_rows(void); + static void read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col); + static void unselect_cols(void); + static void unselect_col(uint8_t col); + static void select_col(uint8_t col); #endif -static matrix_row_t read_cols(void); -static void init_cols(void); -static void unselect_rows(void); -static void select_row(uint8_t row); - __attribute__ ((weak)) void matrix_init_quantum(void) { matrix_init_kb(); @@ -95,7 +117,7 @@ uint8_t matrix_cols(void) { } // void matrix_power_up(void) { -// #if DIODE_DIRECTION == COL2ROW +// #if (DIODE_DIRECTION == COL2ROW) // for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) { // /* DDRxn */ // _SFR_IO8((row_pins[r] >> 4) + 1) |= _BV(row_pins[r] & 0xF); @@ -119,19 +141,26 @@ uint8_t matrix_cols(void) { // } void matrix_init(void) { + // To use PORTF disable JTAG with writing JTD bit twice within four cycles. - #ifdef __AVR_ATmega32U4__ + #if (defined(__AVR_AT90USB1286__) || defined(__AVR_AT90USB1287__) || defined(__AVR_ATmega32U4__)) MCUCR |= _BV(JTD); MCUCR |= _BV(JTD); #endif // initialize row and col +#if (DIODE_DIRECTION == COL2ROW) unselect_rows(); init_cols(); +#else // ROW2COL + unselect_cols(); + init_rows(); +#endif // initialize matrix state: all keys off for (uint8_t i=0; i < MATRIX_ROWS; i++) { matrix[i] = 0; + matrix_raw[i] = 0; matrix_debouncing[i] = 0; } @@ -141,65 +170,81 @@ void matrix_init(void) { uint8_t matrix_scan(void) { -#if DIODE_DIRECTION == COL2ROW - for (uint8_t i = 0; i < MATRIX_ROWS; i++) { - select_row(i); - wait_us(30); // without this wait read unstable value. - matrix_row_t cols = read_cols(); - if (matrix_debouncing[i] != cols) { - matrix_debouncing[i] = cols; - if (debouncing) { - debug("bounce!: "); debug_hex(debouncing); debug("\n"); - } - debouncing = DEBOUNCING_DELAY; - } - unselect_rows(); - } +#if (DIODE_DIRECTION == COL2ROW) - if (debouncing) { - if (--debouncing) { - wait_ms(1); - } else { - for (uint8_t i = 0; i < MATRIX_ROWS; i++) { - matrix[i] = matrix_debouncing[i]; - } - } - } -#else - for (uint8_t i = 0; i < MATRIX_COLS; i++) { - select_row(i); - wait_us(30); // without this wait read unstable value. - matrix_row_t rows = read_cols(); - if (matrix_reversed_debouncing[i] != rows) { - matrix_reversed_debouncing[i] = rows; - if (debouncing) { - debug("bounce!: "); debug_hex(debouncing); debug("\n"); - } - debouncing = DEBOUNCING_DELAY; - } - unselect_rows(); + // Set row, read cols + for (uint8_t current_row = 0; current_row < MATRIX_ROWS; current_row++) { + read_cols_on_row(matrix, current_row); } - if (debouncing) { - if (--debouncing) { - wait_ms(1); - } else { - for (uint8_t i = 0; i < MATRIX_COLS; i++) { - matrix_reversed[i] = matrix_reversed_debouncing[i]; - } - } - } - for (uint8_t y = 0; y < MATRIX_ROWS; y++) { - matrix_row_t row = 0; - for (uint8_t x = 0; x < MATRIX_COLS; x++) { - row |= ((matrix_reversed[x] & (1<<y)) >> y) << x; - } - matrix[y] = row; + // select_row(i); + // wait_us(30); // without this wait read unstable value. + // matrix_row_t current_row = read_cols(); + // if (matrix_debouncing[i] != current_row) { + // matrix_debouncing[i] = current_row; + // if (debouncing) { + // debug("bounce!: "); debug_hex(debouncing); debug("\n"); + // } + // debouncing = DEBOUNCING_DELAY; + // } + // unselect_row(i); + // } + + // if (debouncing) { + // if (--debouncing) { + // wait_ms(1); + // } else { + // for (uint8_t i = 0; i < MATRIX_ROWS; i++) { + // matrix[i] = matrix_debouncing[i]; + // } + // } + // } + +#else // ROW2COL + + // Set col, read rows + for (uint8_t current_col = 0; current_col < MATRIX_COLS; current_col++) { + read_rows_on_col(matrix, current_col); } + + + // for (uint8_t i = 0; i < MATRIX_COLS; i++) { + // select_col(i); + // wait_us(30); // without this wait read unstable value. + // matrix_col_t current_col = read_rows(); + // if (matrix_transposed_debouncing[i] != current_col) { + // matrix_transposed_debouncing[i] = current_col; + // if (debouncing) { + // debug("bounce!: "); debug_hex(debouncing); debug("\n"); + // } + // debouncing = DEBOUNCING_DELAY; + // } + // unselect_col(i); + // } + + // if (debouncing) { + // if (--debouncing) { + // wait_ms(1); + // } else { + // for (uint8_t i = 0; i < MATRIX_COLS; i++) { + // matrix_transposed[i] = matrix_transposed_debouncing[i]; + // } + // } + // } + + // // Untranspose matrix + // for (uint8_t y = 0; y < MATRIX_ROWS; y++) { + // matrix_row_t row = 0; + // for (uint8_t x = 0; x < MATRIX_COLS; x++) { + // row |= ((matrix_transposed[x] & (1<<y)) >> y) << x; + // } + // matrix[y] = row; + // } + #endif matrix_scan_quantum(); - +// matrix_print(); return 1; } @@ -218,15 +263,22 @@ bool matrix_is_on(uint8_t row, uint8_t col) inline matrix_row_t matrix_get_row(uint8_t row) { + // Matrix mask lets you disable switches in the returned matrix data. For example, if you have a + // switch blocker installed and the switch is always pressed. +#ifdef MATRIX_MASKED + return matrix[row] & matrix_mask[row]; +#else return matrix[row]; +#endif } void matrix_print(void) { - print("\nr/c 0123456789ABCDEF\n"); + print_matrix_header(); + for (uint8_t row = 0; row < MATRIX_ROWS; row++) { phex(row); print(": "); - pbin_reverse16(matrix_get_row(row)); + print_matrix_row(row); print("\n"); } } @@ -235,63 +287,130 @@ uint8_t matrix_key_count(void) { uint8_t count = 0; for (uint8_t i = 0; i < MATRIX_ROWS; i++) { - count += bitpop16(matrix[i]); + count += matrix_bitpop(i); } return count; } + + +#if (DIODE_DIRECTION == COL2ROW) + static void init_cols(void) { -#if DIODE_DIRECTION == COL2ROW - for(int x = 0; x < MATRIX_COLS; x++) { - int pin = col_pins[x]; -#else - for(int x = 0; x < MATRIX_ROWS; x++) { - int pin = row_pins[x]; -#endif - _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); - _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); + for(uint8_t x = 0; x < MATRIX_COLS; x++) { + uint8_t pin = col_pins[x]; + _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN + _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI } } -static matrix_row_t read_cols(void) +static void read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row) { - matrix_row_t result = 0; + // Clear data in matrix row + current_matrix[current_row] = 0; -#if DIODE_DIRECTION == COL2ROW - for(int x = 0; x < MATRIX_COLS; x++) { - int pin = col_pins[x]; -#else - for(int x = 0; x < MATRIX_ROWS; x++) { - int pin = row_pins[x]; -#endif - result |= (_SFR_IO8(pin >> 4) & _BV(pin & 0xF)) ? 0 : (SHIFTER << x); + // Select row and wait for row selecton to stabilize + select_row(current_row); + wait_us(30); + + // For each col... + for(uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) { + + // Select the col pin to read (active low) + uint8_t pin = col_pins[col_index]; + uint8_t pin_state = (_SFR_IO8(pin >> 4) & _BV(pin & 0xF)); + + // Populate the matrix row with the state of the col pin + current_matrix[current_row] |= pin_state ? 0 : (ROW_SHIFTER << col_index); } - return result; + + // Unselect row + unselect_row(current_row); +} + +static void select_row(uint8_t row) +{ + uint8_t pin = row_pins[row]; + _SFR_IO8((pin >> 4) + 1) |= _BV(pin & 0xF); // OUT + _SFR_IO8((pin >> 4) + 2) &= ~_BV(pin & 0xF); // LOW +} + +static void unselect_row(uint8_t row) +{ + uint8_t pin = row_pins[row]; + _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN + _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI } static void unselect_rows(void) { -#if DIODE_DIRECTION == COL2ROW - for(int x = 0; x < MATRIX_ROWS; x++) { - int pin = row_pins[x]; -#else - for(int x = 0; x < MATRIX_COLS; x++) { - int pin = col_pins[x]; -#endif - _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); - _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); + for(uint8_t x = 0; x < MATRIX_ROWS; x++) { + uint8_t pin = row_pins[x]; + _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN + _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI } } -static void select_row(uint8_t row) +#else // ROW2COL + +static void init_rows(void) { + for(uint8_t x = 0; x < MATRIX_ROWS; x++) { + uint8_t pin = row_pins[x]; + _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN + _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI + } +} -#if DIODE_DIRECTION == COL2ROW - int pin = row_pins[row]; -#else - int pin = col_pins[row]; -#endif - _SFR_IO8((pin >> 4) + 1) |= _BV(pin & 0xF); - _SFR_IO8((pin >> 4) + 2) &= ~_BV(pin & 0xF); +static void read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col) +{ + + // Select col and wait for col selecton to stabilize + select_col(current_col); + wait_us(30); + + // For each row... + for(uint8_t row_index = 0; row_index < MATRIX_ROWS; row_index++) { + + // Check row pin state + if ((_SFR_IO8(row_pins[row_index] >> 4) & _BV(row_pins[row_index] & 0xF)) == 0) + { + // Pin LO, set col bit + current_matrix[row_index] |= (ROW_SHIFTER << current_col); + } + else + { + // Pin HI, clear col bit + current_matrix[row_index] &= ~(ROW_SHIFTER << current_col); + } + } + + // Unselect col + unselect_col(current_col); +} + +static void select_col(uint8_t col) +{ + uint8_t pin = col_pins[col]; + _SFR_IO8((pin >> 4) + 1) |= _BV(pin & 0xF); // OUT + _SFR_IO8((pin >> 4) + 2) &= ~_BV(pin & 0xF); // LOW } + +static void unselect_col(uint8_t col) +{ + uint8_t pin = col_pins[col]; + _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN + _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI +} + +static void unselect_cols(void) +{ + for(uint8_t x = 0; x < MATRIX_COLS; x++) { + uint8_t pin = col_pins[x]; + _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN + _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI + } +} + +#endif diff --git a/quantum/process_keycode/process_midi.c b/quantum/process_keycode/process_midi.c index 8784e64f3..577dad43a 100644 --- a/quantum/process_keycode/process_midi.c +++ b/quantum/process_keycode/process_midi.c @@ -7,7 +7,9 @@ int midi_offset = 7; bool process_midi(uint16_t keycode, keyrecord_t *record) { if (keycode == MI_ON && record->event.pressed) { midi_activated = true; +#ifdef AUDIO_ENABLE music_scale_user(); +#endif return false; } @@ -63,4 +65,4 @@ bool process_midi(uint16_t keycode, keyrecord_t *record) { return false; } return true; -}
\ No newline at end of file +} diff --git a/quantum/process_keycode/process_unicode.c b/quantum/process_keycode/process_unicode.c index a5d7dca21..cd3a610b4 100644 --- a/quantum/process_keycode/process_unicode.c +++ b/quantum/process_keycode/process_unicode.c @@ -2,6 +2,7 @@ static uint8_t input_mode; +__attribute__((weak)) uint16_t hex_to_keycode(uint8_t hex) { if (hex == 0x0) { @@ -41,6 +42,11 @@ void unicode_input_start (void) { register_code(KC_PPLS); unregister_code(KC_PPLS); break; + case UC_WINC: + register_code(KC_RALT); + unregister_code(KC_RALT); + register_code(KC_U); + unregister_code(KC_U); } wait_ms(UNICODE_TYPE_DELAY); } @@ -77,6 +83,52 @@ bool process_unicode(uint16_t keycode, keyrecord_t *record) { return true; } +#ifdef UNICODEMAP_ENABLE +__attribute__((weak)) +const uint32_t PROGMEM unicode_map[] = { +}; + +void register_hex32(uint32_t hex) { + uint8_t onzerostart = 1; + for(int i = 7; i >= 0; i--) { + if (i <= 3) { + onzerostart = 0; + } + uint8_t digit = ((hex >> (i*4)) & 0xF); + if (digit == 0) { + if (onzerostart == 0) { + register_code(hex_to_keycode(digit)); + unregister_code(hex_to_keycode(digit)); + } + } else { + register_code(hex_to_keycode(digit)); + unregister_code(hex_to_keycode(digit)); + onzerostart = 0; + } + } +} + +__attribute__((weak)) +void unicode_map_input_error() {} + +bool process_unicode_map(uint16_t keycode, keyrecord_t *record) { + if ((keycode & QK_UNICODE_MAP) == QK_UNICODE_MAP && record->event.pressed) { + const uint32_t* map = unicode_map; + uint16_t index = keycode & 0x7FF; + uint32_t code = pgm_read_dword_far(&map[index]); + if ((code > 0xFFFF && input_mode == UC_OSX) || (code > 0xFFFFF && input_mode == UC_LNX)) { + // when character is out of range supported by the OS + unicode_map_input_error(); + } else { + unicode_input_start(); + register_hex32(code); + unicode_input_finish(); + } + } + return true; +} +#endif + #ifdef UCIS_ENABLE qk_ucis_state_t qk_ucis_state; diff --git a/quantum/process_keycode/process_unicode.h b/quantum/process_keycode/process_unicode.h index 27f8072ee..065eeb5f6 100644 --- a/quantum/process_keycode/process_unicode.h +++ b/quantum/process_keycode/process_unicode.h @@ -3,10 +3,11 @@ #include "quantum.h" -#define UC_OSX 0 -#define UC_LNX 1 -#define UC_WIN 2 -#define UC_BSD 3 +#define UC_OSX 0 // Mac OS X +#define UC_LNX 1 // Linux +#define UC_WIN 2 // Windows 'HexNumpad' +#define UC_BSD 3 // BSD (not implemented) +#define UC_WINC 4 // WinCompose https://github.com/samhocevar/wincompose #ifndef UNICODE_TYPE_DELAY #define UNICODE_TYPE_DELAY 10 @@ -20,6 +21,10 @@ void register_hex(uint16_t hex); bool process_unicode(uint16_t keycode, keyrecord_t *record); +#ifdef UNICODEMAP_ENABLE +bool process_unicode_map(uint16_t keycode, keyrecord_t *record); +#endif + #ifdef UCIS_ENABLE #ifndef UCIS_MAX_SYMBOL_LENGTH #define UCIS_MAX_SYMBOL_LENGTH 32 diff --git a/quantum/quantum.c b/quantum/quantum.c index a16bd5443..098312e6e 100644 --- a/quantum/quantum.c +++ b/quantum/quantum.c @@ -129,6 +129,9 @@ bool process_record_quantum(keyrecord_t *record) { #ifdef UCIS_ENABLE process_ucis(keycode, record) && #endif + #ifdef UNICODEMAP_ENABLE + process_unicode_map(keycode, record) && + #endif true)) { return false; } diff --git a/quantum/rgblight.c b/quantum/rgblight.c index f82e3ec55..d550c5866 100644 --- a/quantum/rgblight.c +++ b/quantum/rgblight.c @@ -6,24 +6,37 @@ #include "rgblight.h" #include "debug.h" +// Lightness curve using the CIE 1931 lightness formula +//Generated by the python script provided in http://jared.geek.nz/2013/feb/linear-led-pwm const uint8_t DIM_CURVE[] PROGMEM = { - 0, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, - 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, - 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, - 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, - 8, 8, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 11, 11, 11, - 11, 11, 12, 12, 12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 14, 15, - 15, 15, 16, 16, 16, 16, 17, 17, 17, 18, 18, 18, 19, 19, 19, 20, - 20, 20, 21, 21, 22, 22, 22, 23, 23, 24, 24, 25, 25, 25, 26, 26, - 27, 27, 28, 28, 29, 29, 30, 30, 31, 32, 32, 33, 33, 34, 35, 35, - 36, 36, 37, 38, 38, 39, 40, 40, 41, 42, 43, 43, 44, 45, 46, 47, - 48, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, - 63, 64, 65, 66, 68, 69, 70, 71, 73, 74, 75, 76, 78, 79, 81, 82, - 83, 85, 86, 88, 90, 91, 93, 94, 96, 98, 99, 101, 103, 105, 107, 109, - 110, 112, 114, 116, 118, 121, 123, 125, 127, 129, 132, 134, 136, 139, 141, 144, - 146, 149, 151, 154, 157, 159, 162, 165, 168, 171, 174, 177, 180, 183, 186, 190, - 193, 196, 200, 203, 207, 211, 214, 218, 222, 226, 230, 234, 238, 242, 248, 255 -}; + 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, + 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, + 5, 5, 6, 6, 6, 6, 6, 7, 7, 7, + 7, 8, 8, 8, 8, 9, 9, 9, 10, 10, + 10, 10, 11, 11, 11, 12, 12, 12, 13, 13, + 13, 14, 14, 15, 15, 15, 16, 16, 17, 17, + 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, + 22, 23, 23, 24, 24, 25, 25, 26, 26, 27, + 28, 28, 29, 29, 30, 31, 31, 32, 32, 33, + 34, 34, 35, 36, 37, 37, 38, 39, 39, 40, + 41, 42, 43, 43, 44, 45, 46, 47, 47, 48, + 49, 50, 51, 52, 53, 54, 54, 55, 56, 57, + 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, + 68, 70, 71, 72, 73, 74, 75, 76, 77, 79, + 80, 81, 82, 83, 85, 86, 87, 88, 90, 91, + 92, 94, 95, 96, 98, 99, 100, 102, 103, 105, + 106, 108, 109, 110, 112, 113, 115, 116, 118, 120, + 121, 123, 124, 126, 128, 129, 131, 132, 134, 136, + 138, 139, 141, 143, 145, 146, 148, 150, 152, 154, + 155, 157, 159, 161, 163, 165, 167, 169, 171, 173, + 175, 177, 179, 181, 183, 185, 187, 189, 191, 193, + 196, 198, 200, 202, 204, 207, 209, 211, 214, 216, + 218, 220, 223, 225, 228, 230, 232, 235, 237, 240, + 242, 245, 247, 250, 252, 255, + }; + const uint8_t RGBLED_BREATHING_TABLE[] PROGMEM = { 0, 0, 0, 0, 1, 1, 1, 2, 2, 3, 4, 5, 5, 6, 7, 9, 10, 11, 12, 14, 15, 17, 18, 20, 21, 23, 25, 27, 29, 31, 33, 35, @@ -42,10 +55,16 @@ const uint8_t RGBLED_BREATHING_TABLE[] PROGMEM = { 37, 35, 33, 31, 29, 27, 25, 23, 21, 20, 18, 17, 15, 14, 12, 11, 10, 9, 7, 6, 5, 5, 4, 3, 2, 2, 1, 1, 1, 0, 0, 0 }; + +__attribute__ ((weak)) const uint8_t RGBLED_BREATHING_INTERVALS[] PROGMEM = {30, 20, 10, 5}; +__attribute__ ((weak)) const uint8_t RGBLED_RAINBOW_MOOD_INTERVALS[] PROGMEM = {120, 60, 30}; +__attribute__ ((weak)) const uint8_t RGBLED_RAINBOW_SWIRL_INTERVALS[] PROGMEM = {100, 50, 20}; +__attribute__ ((weak)) const uint8_t RGBLED_SNAKE_INTERVALS[] PROGMEM = {100, 50, 20}; +__attribute__ ((weak)) const uint8_t RGBLED_KNIGHT_INTERVALS[] PROGMEM = {100, 50, 20}; rgblight_config_t rgblight_config; @@ -55,13 +74,8 @@ uint8_t rgblight_inited = 0; void sethsv(uint16_t hue, uint8_t sat, uint8_t val, struct cRGB *led1) { - // Convert hue, saturation, and value (HSV/HSB) to RGB. DIM_CURVE is used only - // on value and saturation (inverted). This looks the most natural. uint8_t r = 0, g = 0, b = 0, base, color; - val = pgm_read_byte(&DIM_CURVE[val]); - sat = 255 - pgm_read_byte(&DIM_CURVE[255 - sat]); - if (sat == 0) { // Acromatic color (gray). Hue doesn't mind. r = val; g = val; @@ -103,6 +117,9 @@ void sethsv(uint16_t hue, uint8_t sat, uint8_t val, struct cRGB *led1) { break; } } + r = pgm_read_byte(&DIM_CURVE[r]); + g = pgm_read_byte(&DIM_CURVE[g]); + b = pgm_read_byte(&DIM_CURVE[b]); setrgb(r, g, b, led1); } diff --git a/quantum/rgblight.h b/quantum/rgblight.h index def26c428..17f04ffcf 100644 --- a/quantum/rgblight.h +++ b/quantum/rgblight.h @@ -40,6 +40,12 @@ #include "eeconfig.h" #include "light_ws2812.h" +extern const uint8_t RGBLED_BREATHING_INTERVALS[4] PROGMEM; +extern const uint8_t RGBLED_RAINBOW_MOOD_INTERVALS[3] PROGMEM; +extern const uint8_t RGBLED_RAINBOW_SWIRL_INTERVALS[3] PROGMEM; +extern const uint8_t RGBLED_SNAKE_INTERVALS[3] PROGMEM; +extern const uint8_t RGBLED_KNIGHT_INTERVALS[3] PROGMEM; + typedef union { uint32_t raw; struct { |