alvierahman90/qmk_firmware
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Add VIA support to MxSS, plus minor tweaks (#7809)

Browse Source 
* Add VIA support to mxss and general cleanup

* Add support for RGB test for FLEDs

* Add LAYOUT_all to allow for more configuration

* Remove blank layers

* Updated readme

* Improve use of EEPROM

* Credit where its due

* Use the latest iteration of rgblight code

* Keep the RGB timer running if the front LED is in RGB mode

* Fix RGB breathing animation

* Better supported RGB animation
Only thing not working is alternating, but that's not too important

* Abstract front LED handlers from main kb code

* Add support for indicator LED color changing

* Remove debug statement

* Persist indicator LED colors

* Mark custom sections in rgblight.c

* Light commenting

* Fix up keymaps

* Add/update comments

* Remove bloat from default hex

* Tidy a stray tab

* Out with the old, in with the new

* Out with the old, in with the new

* Add LAYER_STATE_8BIT for VIA keymap
This commit is contained in:
Jumail Mundekkat 2020-01-27 09:06:56 +11:00 committed by ridingqwerty
parent 7f7b6b08e8
commit 645c5fabf2
14 changed files with 1678 additions and 956 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
keyboards/mxss/config.h
View File

@ -21,12 +21,12 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "config_common.h" #include "config_common.h"
/* USB Device descriptor parameter */ /* USB Device descriptor parameter */
#define VENDOR_ID 0xFEED #define VENDOR_ID 0x4D78 // "Mx" -> MxBlue
#define PRODUCT_ID 0x6060 #define PRODUCT_ID 0x5353 // "SS" -> MxSS
#define DEVICE_VER 0x0001 #define DEVICE_VER 0x0001
#define MANUFACTURER MxBlue #define MANUFACTURER MxBlue
#define PRODUCT MxSS #define PRODUCT MxSS
#define DESCRIPTION Custom Polycarb Keyboard #define DESCRIPTION MxSS Polycarb Keyboard
/* key matrix size */ /* key matrix size */
#define MATRIX_ROWS 5 #define MATRIX_ROWS 5
@ -56,6 +56,13 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
/* Locking resynchronize hack */ /* Locking resynchronize hack */
#define LOCKING_RESYNC_ENABLE #define LOCKING_RESYNC_ENABLE
// Just for posterity, define bootlite matrix pos
#define BOOTMAGIC_LITE_ROW 0
#define BOOTMAGIC_LITE_COLUMN 0
// FLED config takes up 1 byte, stored color count takes 1, stored colors take up to 8
#define VIA_EEPROM_CUSTOM_CONFIG_SIZE 10
/* If defined, GRAVE_ESC will always act as ESC when CTRL is held. /* If defined, GRAVE_ESC will always act as ESC when CTRL is held.
* This is userful for the Windows task manager shortcut (ctrl+shift+esc). * This is userful for the Windows task manager shortcut (ctrl+shift+esc).
*/ */

15
keyboards/mxss/keymaps/default/keymap.c
View File

@ -15,24 +15,25 @@
*/ */
#include QMK_KEYBOARD_H #include QMK_KEYBOARD_H
hs_set caps_color = { .hue = 0, .sat = 255 };
// Colors for layers // Colors for layers
// Format: {hue, saturation} // Format: {hue, saturation}
// {0, 0} to turn off the LED // {0, 0} to turn off the LED
// Add additional rows to handle more layers // Add additional rows to handle more layers
const hs_set layer_colors[] = { hs_set layer_colors[4] = {
[0] = {0, 0}, // Color for Layer 0 [0] = {.hue = 0, .sat = 0}, // Color for Layer 0
[1] = {86, 255}, // Color for Layer 1 [1] = {.hue = 86, .sat = 255}, // Color for Layer 1
[2] = {36, 255}, // Color for Layer 2 [2] = {.hue = 36, .sat = 255}, // Color for Layer 2
[3] = {185, 255}, // Color for Layer 3 [3] = {.hue = 185, .sat = 255}, // Color for Layer 3
}; };
const size_t lc_size = sizeof(layer_colors) / sizeof(uint16_t); size_t lc_size = sizeof(layer_colors) / sizeof(uint16_t);
// Use NEW_SAFE_RANGE to define new custom keycodes in order to not overwrite the ones used for front LED control // Use NEW_SAFE_RANGE to define new custom keycodes in order to not overwrite the ones used for front LED control
enum custom_keycodes { enum custom_keycodes {
MY_KEYCODE = NEW_SAFE_RANGE, MY_KEYCODE = NEW_SAFE_RANGE,
}; };
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
LAYOUT( /* Base */ LAYOUT( /* Base */
KC_GESC, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_MINS, KC_EQL, KC_BSPC, KC_GESC, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_MINS, KC_EQL, KC_BSPC,

19
keyboards/mxss/keymaps/via/config.h Normal file
View File

@ -0,0 +1,19 @@
/* Copyright 2018 Jumail Mundekkat / MxBlue
*
* 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
#define LAYER_STATE_8BIT

33
keyboards/mxss/keymaps/via/keymap.c Normal file
View File

@ -0,0 +1,33 @@
/* Copyright 2018 Jumail Mundekkat / MxBlue
*
* 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
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
LAYOUT_all( /* L0 */
KC_GESC, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_MINS, KC_EQL, KC_NO, 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_LBRC, KC_RBRC, KC_BSLS, KC_DEL,
KC_CAPSLOCK, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, KC_NO, KC_ENT, KC_PGUP,
KC_LSFT, KC_NO, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_RSFT, KC_UP, KC_PGDN,
KC_LCTL, KC_LGUI, KC_LALT, KC_SPACE, KC_SPACE, KC_SPACE, KC_RALT, MO(1), KC_LEFT, KC_DOWN, KC_RGHT
),
LAYOUT_all( /* L1 */
KC_GRV, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, KC_TRNS, KC_TRNS,
KC_TRNS, KC_MPLY, KC_MPRV, KC_MNXT, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_HOME, KC_PSCR, FLED_VAD, FLED_VAI, FLED_MOD, RGB_VAI,
RESET, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_END, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, RGB_VAD,
KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_MUTE, KC_VOLD, KC_VOLU, KC_TRNS, RGB_MOD, RGB_SAI, RGB_TOG,
KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, RGB_HUD, RGB_SAD, RGB_HUI
)
};

1
keyboards/mxss/keymaps/via/rules.mk Normal file
View File

@ -0,0 +1 @@
VIA_ENABLE = yes

203
keyboards/mxss/mxss.c
View File

@ -1,4 +1,4 @@
/* Copyright 2018 Jumail Mundekkat / MxBlue /* Copyright 2020 Jumail Mundekkat / MxBlue
* *
* This program is free software: you can redistribute it and/or modify * This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by * it under the terms of the GNU General Public License as published by
@ -12,63 +12,29 @@
* *
* You should have received a copy of the GNU General Public License * You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>. * along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* EEPROM management code from ../cannonkeys/stm32f072/keyboard.c
*/ */
#include QMK_KEYBOARD_H #include QMK_KEYBOARD_H
#include "tmk_core/common/eeprom.h" #include "tmk_core/common/eeprom.h"
#include "tmk_core/common/action_layer.h" #include "tmk_core/common/action_layer.h"
#include "rgblight.h" #include "rgblight.h"
#include "via.h"
#include "version.h" // for QMK_BUILDDATE used in EEPROM magic
// Variables for controlling front LED application void via_init_kb(void) {
uint8_t fled_mode; // Mode for front LEDs fled_init();
uint8_t fled_val; // Brightness for front leds (0 - 255) }
LED_TYPE fleds[2]; // Front LED rgb values for indicator mode use
// Predefined colors for layers
// Format: {hue, saturation}
// {0, 0} to turn off the LED
// Add additional rows to handle more layers
__attribute__ ((weak))
const hs_set layer_colors[] = {
[0] = {0, 0}, // Color for Layer 0
[1] = {86, 255}, // Color for Layer 1
[2] = {36, 255}, // Color for Layer 2
[3] = {185, 255}, // Color for Layer 3
};
__attribute__ ((weak))
const size_t lc_size = sizeof(layer_colors) / sizeof(uint16_t);
void matrix_init_kb(void) { void matrix_init_kb(void) {
// If EEPROM config exists, load it // If VIA is disabled, we still need to load settings
if (eeprom_is_valid()) { // Call via_init_kb() the same way as via_init(), with setting
fled_config fled_conf; // EEPROM valid afterwards.
fled_conf.raw = eeprom_read_byte(EEPROM_FRONTLED_ADDR); #ifndef VIA_ENABLE
fled_mode = fled_conf.mode; fled_init();
fled_val = fled_conf.val * FLED_VAL_STEP; via_eeprom_set_valid(true);
// Else, default config #endif // VIA_ENABLE
} else {
fled_mode = FLED_RGB;
fled_val = 10 * FLED_VAL_STEP;
eeprom_update_conf(); // Store default config to EEPROM
}
// Set default values for leds
setrgb(0, 0, 0, &fleds[0]);
setrgb(0, 0, 0, &fleds[1]);
// Handle lighting for indicator mode
if (fled_mode == FLED_INDI) {
// Enable capslock led if enabled on host
if (host_keyboard_leds() & (1<<USB_LED_CAPS_LOCK))
sethsv(FLED_CAPS_H, FLED_CAPS_S, fled_val, &fleds[0]);
// Determine and set colour of layer LED according to current layer
// if hue = sat = 0, leave LED off
uint8_t layer = biton32(layer_state);
if (layer < lc_size && !(layer_colors[layer].hue == 0 && layer_colors[layer].hue == 0))
sethsv(layer_colors[layer].hue, layer_colors[layer].sat, fled_val, &fleds[1]);
}
matrix_init_user(); matrix_init_user();
} }
@ -82,132 +48,35 @@ void matrix_scan_kb(void) {
bool process_record_kb(uint16_t keycode, keyrecord_t *record) { bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
// Handle custom keycodes for front LED operation // Handle custom keycodes for front LED operation
switch (keycode) { process_record_fled(keycode, record);
case FLED_MOD: // Change between front LED operation modes (off, indicator, RGB)
if (record->event.pressed)
fled_mode_cycle();
break;
case FLED_VAI: // Increase the brightness of the front LEDs by FLED_VAL_STEP
if (record->event.pressed)
fled_val_increase();
break;
case FLED_VAD: // Decrease the brightness of the front LEDs by FLED_VAL_STEP
if (record->event.pressed)
fled_val_decrease();
break;
default:
break; // Process all other keycodes normally
}
return process_record_user(keycode, record); return process_record_user(keycode, record);
} }
void led_set_kb(uint8_t usb_led) { bool led_update_kb(led_t led_state) {
// Set indicator LED appropriately, whether it is used or not fled_lock_update(led_state);
if (usb_led & (1 << USB_LED_CAPS_LOCK)) { return led_update_user(led_state);
sethsv(FLED_CAPS_H, FLED_CAPS_S, fled_val, &fleds[0]);
} else {
setrgb(0, 0, 0, &fleds[0]);
} }
rgblight_set(); layer_state_t layer_state_set_kb(layer_state_t state) {
led_set_user(usb_led); fled_layer_update(state);
return layer_state_set_user(state);
} }
uint32_t layer_state_set_kb(uint32_t state) { // Fallback eeprom functions if VIA is not enabled
// Determine and set colour of layer LED according to current layer #ifndef VIA_ENABLE
// if hue = sat = 0, leave LED off
uint8_t layer = biton32(state);
if (layer < lc_size && !(layer_colors[layer].hue == 0 && layer_colors[layer].hue == 0)) // Sets VIA/keyboard level usage of EEPROM to valid/invalid
sethsv(layer_colors[layer].hue, layer_colors[layer].sat, fled_val, &fleds[1]); // Keyboard level code (eg. via_init_kb()) should not call this
else void via_eeprom_set_valid(bool valid)
setrgb(0, 0, 0, &fleds[1]);
return state;
}
// EEPROM Management
// Test if magic value is present at expected location
bool eeprom_is_valid(void)
{ {
return (eeprom_read_word(EEPROM_MAGIC_ADDR) == EEPROM_MAGIC); char *p = QMK_BUILDDATE; // e.g. "2019-11-05-11:29:54"
uint8_t magic0 = ( ( p[2] & 0x0F ) << 4 ) | ( p[3] & 0x0F );
uint8_t magic1 = ( ( p[5] & 0x0F ) << 4 ) | ( p[6] & 0x0F );
uint8_t magic2 = ( ( p[8] & 0x0F ) << 4 ) | ( p[9] & 0x0F );
eeprom_update_byte( (void*)VIA_EEPROM_MAGIC_ADDR+0, valid ? magic0 : 0xFF);
eeprom_update_byte( (void*)VIA_EEPROM_MAGIC_ADDR+1, valid ? magic1 : 0xFF);
eeprom_update_byte( (void*)VIA_EEPROM_MAGIC_ADDR+2, valid ? magic2 : 0xFF);
} }
// Set magic value at expected location #endif
void eeprom_set_valid(bool valid)
{
eeprom_update_word(EEPROM_MAGIC_ADDR, valid ? EEPROM_MAGIC : 0xFFFF);
}
// Store current front led config in EEPROM
void eeprom_update_conf(void)
{
// Create storage struct and set values
fled_config conf;
conf.mode = fled_mode;
// Small hack to ensure max value is stored correctly
if (fled_val == 255)
conf.val = 256 / FLED_VAL_STEP;
else
conf.val = fled_val / FLED_VAL_STEP;
// Set magic value and store config
eeprom_set_valid(true);
eeprom_update_byte(EEPROM_FRONTLED_ADDR, conf.raw);
}
// Custom keycode functions
void fled_mode_cycle(void)
{
// FLED -> FLED_RGB -> FLED_INDI
switch (fled_mode) {
case FLED_OFF:
fled_mode = FLED_RGB;
break;
case FLED_RGB:
fled_mode = FLED_INDI;
break;
case FLED_INDI:
fled_mode = FLED_OFF;
break;
}
// Update stored config
eeprom_update_conf();
rgblight_set();
}
void fled_val_increase(void)
{
// Increase val by FLED_VAL_STEP, handling the upper edge case
if (fled_val + FLED_VAL_STEP > 255)
fled_val = 255;
else
fled_val += FLED_VAL_STEP;
// Update stored config
eeprom_update_conf();
rgblight_set();
}
void fled_val_decrease(void)
{
// Decrease val by FLED_VAL_STEP, handling the lower edge case
if (fled_val - FLED_VAL_STEP > 255)
fled_val = 255;
else
fled_val -= FLED_VAL_STEP;
// Update stored config
eeprom_update_conf();
rgblight_set();
}

19
keyboards/mxss/mxss.h
View File

@ -13,8 +13,7 @@
* You should have received a copy of the GNU General Public License * You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>. * along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
#ifndef MXSS_H #pragma once
#define MXSS_H
#include "quantum.h" #include "quantum.h"
#include "mxss_frontled.h" #include "mxss_frontled.h"
@ -204,4 +203,18 @@
{ k40, k41, k42, k43, KC_NO, KC_NO, k46, KC_NO, k48, KC_NO, k4A, k4B, k4C, k4D, k4E }, \ { k40, k41, k42, k43, KC_NO, KC_NO, k46, KC_NO, k48, KC_NO, k4A, k4B, k4C, k4D, k4E }, \
} }
#endif // All the gubs
#define LAYOUT_all( \
k00, k01, k02, k03, k04, k05, k06, k07, k08, k09, k0A, k0B, k0C, k0D, k0E, \
k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k1A, k1B, k1C, k1D, k1E, \
k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k2A, k2B, k2C, k2D, k2E, \
k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k3A, k3B, k3C, k3D, k3E, \
k40, k41, k42, k43, k46, k48, k4A, k4B, k4C, k4D, k4E \
) \
{ \
{ k00, k01, k02, k03, k04, k05, k06, k07, k08, k09, k0A, k0B, k0C, k0D, k0E }, \
{ k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k1A, k1B, k1C, k1D, k1E }, \
{ k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k2A, k2B, k2C, k2D, k2E }, \
{ k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k3A, k3B, k3C, k3D, k3E }, \
{ k40, k41, k42, k43, KC_NO, KC_NO, k46, KC_NO, k48, KC_NO, k4A, k4B, k4C, k4D, k4E }, \
}

264
keyboards/mxss/mxss_frontled.c Normal file
View File

@ -0,0 +1,264 @@
/* Copyright 2020 Jumail Mundekkat / MxBlue
*
* 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/>.
*
* Extended from the work done by fcoury: https://github.com/qmk/qmk_firmware/pull/4915
*/
#include "mxss_frontled.h"
#include "tmk_core/common/eeprom.h"
#include "rgblight.h"
#include "via.h"
#include "version.h" // for QMK_BUILDDATE used in EEPROM magic
// Variables for controlling front LED application
uint8_t fled_mode; // Mode for front LEDs
uint8_t fled_val; // Brightness for front leds (0 - 255)
LED_TYPE fleds[2]; // Front LED rgb values for indicator mode use
// Layer indicator colors
__attribute__ ((weak))
hs_set layer_colors[FRONTLED_COLOR_MAXCNT];
// Caps lock indicator color
__attribute__ ((weak))
hs_set caps_color;
__attribute__ ((weak))
size_t lc_size = sizeof(layer_colors) / sizeof(hs_set);
void fled_init(void) {
// If EEPROM config exists, load it
// If VIA EEPROM exists, FLED config should too
if (via_eeprom_is_valid()) {
fled_load_conf();
// Else, default config
} else {
// Default mode/brightness
fled_mode = FLED_RGB;
fled_val = 10 * FLED_VAL_STEP;
// Default colors
caps_color.hue = 0;
caps_color.sat = 255;
layer_colors[0].hue = 0;
layer_colors[0].sat = 0;
layer_colors[1].hue = 86;
layer_colors[1].sat = 255;
layer_colors[2].hue = 36;
layer_colors[2].sat = 255;
layer_colors[3].hue = 185;
layer_colors[3].sat = 255;
fled_update_conf(); // Store default config to EEPROM
}
// Set default values for leds
setrgb(0, 0, 0, &fleds[0]);
setrgb(0, 0, 0, &fleds[1]);
// Handle lighting for indicator mode
if (fled_mode == FLED_INDI) {
fled_lock_update(host_keyboard_led_state());
fled_layer_update(layer_state);
}
}
void process_record_fled(uint16_t keycode, keyrecord_t *record) {
// Handle custom keycodes for front LED operation
switch (keycode) {
case FLED_MOD: // Change between front LED operation modes (off, indicator, RGB)
if (record->event.pressed)
fled_mode_cycle();
break;
case FLED_VAI: // Increase the brightness of the front LEDs by FLED_VAL_STEP
if (record->event.pressed)
fled_val_increase();
break;
case FLED_VAD: // Decrease the brightness of the front LEDs by FLED_VAL_STEP
if (record->event.pressed)
fled_val_decrease();
break;
default:
break; // Process all other keycodes normally
}
return;
}
void fled_load_conf(void) {
// Load config
fled_config fled_conf;
fled_conf.raw = eeprom_read_byte(FRONTLED_CONF_ADDR);
fled_mode = fled_conf.mode;
fled_val = fled_conf.val * FLED_VAL_STEP;
// Load color data
uint8_t stored_cnt = eeprom_read_byte(FRONTLED_COLOR_CNT_ADDR);
uint16_t *color_ptr = FRONTLED_COLOR_ADDR;
caps_color.raw = eeprom_read_word(color_ptr); // Should always store at least 1 color
for (uint8_t i = 1; i < stored_cnt; i++) {
if (i == lc_size) // Can't load more layers than we have available
break;
layer_colors[i].raw = eeprom_read_word(&color_ptr[i]);
}
layer_colors[0].raw = 0; // hue = sat = 0 for layer 0
}
// Store current front led config in EEPROM
void fled_update_conf(void)
{
// Create storage struct and set values
fled_config conf;
conf.mode = fled_mode;
// Small hack to ensure max value is stored correctly
if (fled_val == 255)
conf.val = 256 / FLED_VAL_STEP;
else
conf.val = fled_val / FLED_VAL_STEP;
// Store config
eeprom_update_byte(FRONTLED_CONF_ADDR, conf.raw);
// Store color data
uint16_t *color_ptr = FRONTLED_COLOR_ADDR;
eeprom_update_word(color_ptr, caps_color.raw);
// Start from 1, layer 0 is not modifiable and therefore not persisted
uint8_t i = 1;
for (; i < lc_size; i++) {
if (i == FRONTLED_COLOR_MAXCNT) // Can't store more than the EEPROM we have available
break;
eeprom_update_word(&color_ptr[i], layer_colors[i].raw);
}
eeprom_update_byte(FRONTLED_COLOR_CNT_ADDR, i); // For safety, store the count of colors stored
}
// Custom keycode functions
void fled_mode_cycle(void)
{
// FLED -> FLED_RGB -> FLED_INDI
switch (fled_mode) {
case FLED_OFF:
fled_mode = FLED_RGB;
rgblight_timer_enable();
break;
case FLED_RGB:
fled_mode = FLED_INDI;
break;
case FLED_INDI:
fled_mode = FLED_OFF;
break;
}
// Update stored config
fled_update_conf();
rgblight_set();
}
void fled_val_increase(void)
{
// Increase val by FLED_VAL_STEP, handling the upper edge case
if (fled_val + FLED_VAL_STEP > 255)
fled_val = 255;
else
fled_val += FLED_VAL_STEP;
// Update stored config
fled_update_conf();
rgblight_set();
}
void fled_val_decrease(void)
{
// Decrease val by FLED_VAL_STEP, handling the lower edge case
if (fled_val - FLED_VAL_STEP > 255)
fled_val = 255;
else
fled_val -= FLED_VAL_STEP;
// Update stored config
fled_update_conf();
rgblight_set();
}
void fled_layer_update(layer_state_t state) {
// Determine and set colour of layer LED according to current layer
// if hue = sat = 0, leave LED off
uint8_t layer = get_highest_layer(state);
if (layer < lc_size && !(layer_colors[layer].hue == 0 && layer_colors[layer].sat == 0)) {
sethsv(layer_colors[layer].hue, layer_colors[layer].sat, fled_val, &fleds[1]);
} else {
setrgb(0, 0, 0, &fleds[1]);
}
}
void fled_lock_update(led_t led_state) {
// Set indicator LED appropriately, whether it is used or not
if (led_state.caps_lock) {
sethsv(caps_color.hue, caps_color.sat, fled_val, &fleds[0]);
} else {
setrgb(0, 0, 0, &fleds[0]);
}
rgblight_set();
}
void set_fled_layer_color(uint8_t layer, hs_set hs) {
// Update layer colors and refresh LEDs
layer_colors[layer] = hs;
fled_layer_update(layer_state);
fled_update_conf();
}
hs_set get_fled_layer_color(uint8_t layer) {
return layer_colors[layer];
}
void set_fled_caps_color(hs_set hs) {
// Update caplock color and refresh LEDs
caps_color = hs;
fled_lock_update(host_keyboard_led_state());
fled_update_conf();
}
hs_set get_fled_caps_color(void) {
return caps_color;
}
// Fallback eeprom functions if VIA is not enabled
#ifndef VIA_ENABLE
// Can be called in an overriding via_init_kb() to test if keyboard level code usage of
// EEPROM is invalid and use/save defaults.
bool via_eeprom_is_valid(void)
{
char *p = QMK_BUILDDATE; // e.g. "2019-11-05-11:29:54"
uint8_t magic0 = ( ( p[2] & 0x0F ) << 4 ) | ( p[3] & 0x0F );
uint8_t magic1 = ( ( p[5] & 0x0F ) << 4 ) | ( p[6] & 0x0F );
uint8_t magic2 = ( ( p[8] & 0x0F ) << 4 ) | ( p[9] & 0x0F );
return (eeprom_read_byte( (void*)VIA_EEPROM_MAGIC_ADDR+0 ) == magic0 &&
eeprom_read_byte( (void*)VIA_EEPROM_MAGIC_ADDR+1 ) == magic1 &&
eeprom_read_byte( (void*)VIA_EEPROM_MAGIC_ADDR+2 ) == magic2 );
}
#endif

47
keyboards/mxss/mxss_frontled.h
View File

@ -1,4 +1,4 @@
/* Copyright 2018 Jumail Mundekkat / MxBlue /* Copyright 2020 Jumail Mundekkat / MxBlue
* *
* This program is free software: you can redistribute it and/or modify * This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by * it under the terms of the GNU General Public License as published by
@ -17,10 +17,11 @@
// EEPROM management code taken from Wilba6582 // EEPROM management code taken from Wilba6582
// https://github.com/Wilba6582/qmk_firmware/blob/zeal60/keyboards/zeal60/zeal_eeprom.h // https://github.com/Wilba6582/qmk_firmware/blob/zeal60/keyboards/zeal60/zeal_eeprom.h
#ifndef MXSS_FRONTLED_H #pragma once
#define MXSS_FRONTLED_H
#include "quantum.h"
#include "quantum_keycodes.h" #include "quantum_keycodes.h"
#include "via.h"
// RGBLED index for front LEDs // RGBLED index for front LEDs
#define RGBLIGHT_FLED1 14 #define RGBLIGHT_FLED1 14
@ -29,13 +30,13 @@
// Brightness increase step for front LEDs // Brightness increase step for front LEDs
#define FLED_VAL_STEP 8 #define FLED_VAL_STEP 8
// QMK never uses more then 32bytes of EEPROM, so our region starts there
// Magic value to verify the state of the EEPROM
#define EEPROM_MAGIC 0xC3E7
#define EEPROM_MAGIC_ADDR ((void*)32)
// Front LED settings // Front LED settings
#define EEPROM_FRONTLED_ADDR ((void*)34) #define FRONTLED_CONF_ADDR ((uint8_t*) VIA_EEPROM_CUSTOM_CONFIG_ADDR)
#define FRONTLED_COLOR_CNT_ADDR (FRONTLED_CONF_ADDR + 1)
#define FRONTLED_COLOR_ADDR ((uint16_t*)(FRONTLED_COLOR_CNT_ADDR + 1))
// No point persisting more 4, VIA only allows editing of 3 + 1 for caps
#define FRONTLED_COLOR_MAXCNT 4
// Modes for front LEDs // Modes for front LEDs
#define FLED_OFF 0b00 #define FLED_OFF 0b00
@ -43,10 +44,6 @@
#define FLED_RGB 0b10 #define FLED_RGB 0b10
#define FLED_UNDEF 0b11 #define FLED_UNDEF 0b11
// Hard-coded color for capslock indicator in FLED_INDI mode, H:0% S:100% = Red
#define FLED_CAPS_H 0
#define FLED_CAPS_S 255
// Config storage format for EEPROM // Config storage format for EEPROM
typedef union { typedef union {
uint8_t raw; uint8_t raw;
@ -57,25 +54,35 @@ typedef union {
} fled_config; } fled_config;
// Structure to store hue and saturation values // Structure to store hue and saturation values
typedef struct _hs_set { typedef union {
uint16_t hue; uint16_t raw;
struct {
uint8_t hue;
uint8_t sat; uint8_t sat;
};
} hs_set; } hs_set;
// Custom keycodes for front LED control // Custom keycodes for front LED control
enum fled_keycodes { enum fled_keycodes {
FLED_MOD = SAFE_RANGE, FLED_MOD = USER00, // USER00 = VIA custom keycode start
FLED_VAI, FLED_VAI,
FLED_VAD, FLED_VAD,
NEW_SAFE_RANGE // define a new safe range NEW_SAFE_RANGE // define a new safe range
}; };
bool eeprom_is_valid(void); // Check if EEPROM has been set up void fled_init(void); // Run init functions for front LEDs
void eeprom_set_valid(bool valid); // Change validity state of EEPROM void process_record_fled(uint16_t keycode, keyrecord_t* record); // Process keycodes for front LEDs
void eeprom_update_conf(void); // Store current front LED config to EEPROM void fled_load_conf(void); // Load front LED config from EEPROM
void fled_update_conf(void); // Store current front LED config to EEPROM
void fled_mode_cycle(void); // Cycle between the 3 modes for the front LEDs void fled_mode_cycle(void); // Cycle between the 3 modes for the front LEDs
void fled_val_increase(void); // Increase the brightness of the front LEDs void fled_val_increase(void); // Increase the brightness of the front LEDs
void fled_val_decrease(void); // Decrease the brightness of the front LEDs void fled_val_decrease(void); // Decrease the brightness of the front LEDs
#endif //MXSS_FRONTLED_H void fled_layer_update(layer_state_t state); // Process layer update for front LEDs
void fled_lock_update(led_t led_state); // Process lock update for front LEDs
void set_fled_layer_color(uint8_t layer, hs_set hs); // Set color for a given layer
void set_fled_caps_color(hs_set hs); // Set color for the capslock indicator
hs_set get_fled_caps_color(void); // Get color for the capslock indicator
hs_set get_fled_layer_color(uint8_t layer); // Get color for a given layer

5
keyboards/mxss/readme.md
View File

@ -2,6 +2,11 @@
![MxSS - Polycarb 65% Kit for MX/SMK](https://i.imgur.com/WDTWcmU.jpg) ![MxSS - Polycarb 65% Kit for MX/SMK](https://i.imgur.com/WDTWcmU.jpg)
### Important Note:
**This PCB supports the VIA configurator, and this is the recommended way to configure the keymap on this keyboard. Building the firmware should only be necessary if you would like to change the colours of the front LEDs in indicator mode.**
**For more information about the VIA configurator, [see here](https://caniusevia.com/).**
### Information: ### Information:
- Case: Frosted Polycarbonate, CNC milled - Case: Frosted Polycarbonate, CNC milled

1114
keyboards/mxss/rgblight.c
View File

File diff suppressed because it is too large Load Diff

234
keyboards/mxss/rgblight.h
View File

@ -16,15 +16,71 @@
#ifndef RGBLIGHT_H #ifndef RGBLIGHT_H
#define RGBLIGHT_H #define RGBLIGHT_H
#ifdef RGBLIGHT_ANIMATIONS #include "rgblight_reconfig.h"
#define RGBLIGHT_MODES 35
#else
#define RGBLIGHT_MODES 1
#endif
#ifndef RGBLIGHT_EFFECT_BREATHE_CENTER /***** rgblight_mode(mode)/rgblight_mode_noeeprom(mode) ****
#define RGBLIGHT_EFFECT_BREATHE_CENTER 1.85 // 1-2.7
#endif old mode number (before 0.6.117) to new mode name table
|-----------------|-----------------------------------|
| old mode number | new mode name |
|-----------------|-----------------------------------|
| 1 | RGBLIGHT_MODE_STATIC_LIGHT |
| 2 | RGBLIGHT_MODE_BREATHING |
| 3 | RGBLIGHT_MODE_BREATHING + 1 |
| 4 | RGBLIGHT_MODE_BREATHING + 2 |
| 5 | RGBLIGHT_MODE_BREATHING + 3 |
| 6 | RGBLIGHT_MODE_RAINBOW_MOOD |
| 7 | RGBLIGHT_MODE_RAINBOW_MOOD + 1 |
| 8 | RGBLIGHT_MODE_RAINBOW_MOOD + 2 |
| 9 | RGBLIGHT_MODE_RAINBOW_SWIRL |
| 10 | RGBLIGHT_MODE_RAINBOW_SWIRL + 1 |
| 11 | RGBLIGHT_MODE_RAINBOW_SWIRL + 2 |
| 12 | RGBLIGHT_MODE_RAINBOW_SWIRL + 3 |
| 13 | RGBLIGHT_MODE_RAINBOW_SWIRL + 4 |
| 14 | RGBLIGHT_MODE_RAINBOW_SWIRL + 5 |
| 15 | RGBLIGHT_MODE_SNAKE |
| 16 | RGBLIGHT_MODE_SNAKE + 1 |
| 17 | RGBLIGHT_MODE_SNAKE + 2 |
| 18 | RGBLIGHT_MODE_SNAKE + 3 |
| 19 | RGBLIGHT_MODE_SNAKE + 4 |
| 20 | RGBLIGHT_MODE_SNAKE + 5 |
| 21 | RGBLIGHT_MODE_KNIGHT |
| 22 | RGBLIGHT_MODE_KNIGHT + 1 |
| 23 | RGBLIGHT_MODE_KNIGHT + 2 |
| 24 | RGBLIGHT_MODE_CHRISTMAS |
| 25 | RGBLIGHT_MODE_STATIC_GRADIENT |
| 26 | RGBLIGHT_MODE_STATIC_GRADIENT + 1 |
| 27 | RGBLIGHT_MODE_STATIC_GRADIENT + 2 |
| 28 | RGBLIGHT_MODE_STATIC_GRADIENT + 3 |
| 29 | RGBLIGHT_MODE_STATIC_GRADIENT + 4 |
| 30 | RGBLIGHT_MODE_STATIC_GRADIENT + 5 |
| 31 | RGBLIGHT_MODE_STATIC_GRADIENT + 6 |
| 32 | RGBLIGHT_MODE_STATIC_GRADIENT + 7 |
| 33 | RGBLIGHT_MODE_STATIC_GRADIENT + 8 |
| 34 | RGBLIGHT_MODE_STATIC_GRADIENT + 9 |
| 35 | RGBLIGHT_MODE_RGB_TEST |
| 36 | RGBLIGHT_MODE_ALTERNATING |
|-----------------|-----------------------------------|
*****/
#define _RGBM_SINGLE_STATIC(sym) RGBLIGHT_MODE_##sym,
#define _RGBM_SINGLE_DYNAMIC(sym) RGBLIGHT_MODE_##sym,
#define _RGBM_MULTI_STATIC(sym) RGBLIGHT_MODE_##sym,
#define _RGBM_MULTI_DYNAMIC(sym) RGBLIGHT_MODE_##sym,
#define _RGBM_TMP_STATIC(sym, msym) RGBLIGHT_MODE_##sym,
#define _RGBM_TMP_DYNAMIC(sym, msym) RGBLIGHT_MODE_##sym,
enum RGBLIGHT_EFFECT_MODE {
RGBLIGHT_MODE_zero = 0,
#include "rgblight_modes.h"
RGBLIGHT_MODE_last
};
#ifndef RGBLIGHT_H_DUMMY_DEFINE
# define RGBLIGHT_MODES (RGBLIGHT_MODE_last - 1)
// sample: #define RGBLIGHT_EFFECT_BREATHE_CENTER 1.85
# ifndef RGBLIGHT_EFFECT_BREATHE_MAX # ifndef RGBLIGHT_EFFECT_BREATHE_MAX
# define RGBLIGHT_EFFECT_BREATHE_MAX 255 // 0-255 # define RGBLIGHT_EFFECT_BREATHE_MAX 255 // 0-255
@ -43,7 +99,7 @@
# endif # endif
# ifndef RGBLIGHT_EFFECT_KNIGHT_LED_NUM # ifndef RGBLIGHT_EFFECT_KNIGHT_LED_NUM
#define RGBLIGHT_EFFECT_KNIGHT_LED_NUM RGBLED_NUM # define RGBLIGHT_EFFECT_KNIGHT_LED_NUM (effect_num_leds)
# endif # endif
# ifndef RGBLIGHT_EFFECT_CHRISTMAS_INTERVAL # ifndef RGBLIGHT_EFFECT_CHRISTMAS_INTERVAL
@ -55,7 +111,7 @@
# endif # endif
# ifndef RGBLIGHT_HUE_STEP # ifndef RGBLIGHT_HUE_STEP
#define RGBLIGHT_HUE_STEP 10 # define RGBLIGHT_HUE_STEP 8
# endif # endif
# ifndef RGBLIGHT_SAT_STEP # ifndef RGBLIGHT_SAT_STEP
# define RGBLIGHT_SAT_STEP 17 # define RGBLIGHT_SAT_STEP 17
@ -63,6 +119,9 @@
# ifndef RGBLIGHT_VAL_STEP # ifndef RGBLIGHT_VAL_STEP
# define RGBLIGHT_VAL_STEP 17 # define RGBLIGHT_VAL_STEP 17
# endif # endif
# ifndef RGBLIGHT_LIMIT_VAL
# define RGBLIGHT_LIMIT_VAL 255
# endif
# define RGBLED_TIMER_TOP F_CPU / (256 * 64) # define RGBLED_TIMER_TOP F_CPU / (256 * 64)
// #define RGBLED_TIMER_TOP 0xFF10 // #define RGBLED_TIMER_TOP 0xFF10
@ -76,6 +135,10 @@
# include "color.h" # include "color.h"
# include "rgblight_list.h" # include "rgblight_list.h"
# if defined(__AVR__)
# include <avr/pgmspace.h>
# endif
extern LED_TYPE led[RGBLED_NUM]; extern LED_TYPE led[RGBLED_NUM];
extern const uint8_t RGBLED_BREATHING_INTERVALS[4] PROGMEM; extern const uint8_t RGBLED_BREATHING_INTERVALS[4] PROGMEM;
@ -84,47 +147,102 @@ extern const uint8_t RGBLED_RAINBOW_SWIRL_INTERVALS[3] PROGMEM;
extern const uint8_t RGBLED_SNAKE_INTERVALS[3] PROGMEM; extern const uint8_t RGBLED_SNAKE_INTERVALS[3] PROGMEM;
extern const uint8_t RGBLED_KNIGHT_INTERVALS[3] PROGMEM; extern const uint8_t RGBLED_KNIGHT_INTERVALS[3] PROGMEM;
extern const uint16_t RGBLED_RGBTEST_INTERVALS[1] PROGMEM; extern const uint16_t RGBLED_RGBTEST_INTERVALS[1] PROGMEM;
extern bool is_rgblight_initialized;
// Should stay in sycn with rgb matrix config as we reuse eeprom storage for both (for now)
typedef union { typedef union {
uint32_t raw; uint32_t raw;
struct { struct {
bool enable : 1; bool enable : 1;
uint8_t mode :6; uint8_t mode : 7;
uint16_t hue :9; uint8_t hue : 8;
uint8_t sat : 8; uint8_t sat : 8;
uint8_t val : 8; uint8_t val : 8;
uint8_t speed : 8; // EECONFIG needs to be increased to support this uint8_t speed : 8; // EECONFIG needs to be increased to support this
}; };
} rgblight_config_t; } rgblight_config_t;
void rgblight_init(void); typedef struct _rgblight_status_t {
uint8_t base_mode;
bool timer_enabled;
# ifdef RGBLIGHT_SPLIT
uint8_t change_flags;
# endif
} rgblight_status_t;
/* === Utility Functions ===*/
void sethsv(uint8_t hue, uint8_t sat, uint8_t val, LED_TYPE *led1);
void sethsv_raw(uint8_t hue, uint8_t sat, uint8_t val, LED_TYPE *led1); // without RGBLIGHT_LIMIT_VAL check
void setrgb(uint8_t r, uint8_t g, uint8_t b, LED_TYPE *led1);
/* === Low level Functions === */
void rgblight_set(void);
void rgblight_set_clipping_range(uint8_t start_pos, uint8_t num_leds);
/* === Effects and Animations Functions === */
/* effect range setting */
void rgblight_set_effect_range(uint8_t start_pos, uint8_t num_leds);
/* direct operation */
void rgblight_setrgb_at(uint8_t r, uint8_t g, uint8_t b, uint8_t index);
void rgblight_sethsv_at(uint8_t hue, uint8_t sat, uint8_t val, uint8_t index);
void rgblight_setrgb_range(uint8_t r, uint8_t g, uint8_t b, uint8_t start, uint8_t end);
void rgblight_sethsv_range(uint8_t hue, uint8_t sat, uint8_t val, uint8_t start, uint8_t end);
void rgblight_setrgb(uint8_t r, uint8_t g, uint8_t b);
# ifndef RGBLIGHT_SPLIT
void rgblight_setrgb_master(uint8_t r, uint8_t g, uint8_t b);
void rgblight_setrgb_slave(uint8_t r, uint8_t g, uint8_t b);
void rgblight_sethsv_master(uint8_t hue, uint8_t sat, uint8_t val);
void rgblight_sethsv_slave(uint8_t hue, uint8_t sat, uint8_t val);
# endif
/* effect mode change */
void rgblight_mode(uint8_t mode);
void rgblight_mode_noeeprom(uint8_t mode);
void rgblight_increase(void); void rgblight_increase(void);
void rgblight_decrease(void); void rgblight_decrease(void);
void rgblight_toggle(void);
void rgblight_enable(void);
void rgblight_disable(void);
void rgblight_step(void); void rgblight_step(void);
void rgblight_step_noeeprom(void);
void rgblight_step_reverse(void); void rgblight_step_reverse(void);
uint8_t rgblight_get_mode(void); void rgblight_step_reverse_noeeprom(void);
void rgblight_mode(uint8_t mode);
void rgblight_set(void); /* effects mode disable/enable */
void rgblight_update_dword(uint32_t dword); void rgblight_toggle(void);
void rgblight_toggle_noeeprom(void);
void rgblight_enable(void);
void rgblight_enable_noeeprom(void);
void rgblight_disable(void);
void rgblight_disable_noeeprom(void);
/* hue, sat, val change */
void rgblight_increase_hue(void); void rgblight_increase_hue(void);
void rgblight_increase_hue_noeeprom(void);
void rgblight_decrease_hue(void); void rgblight_decrease_hue(void);
void rgblight_decrease_hue_noeeprom(void);
void rgblight_increase_sat(void); void rgblight_increase_sat(void);
void rgblight_increase_sat_noeeprom(void);
void rgblight_decrease_sat(void); void rgblight_decrease_sat(void);
void rgblight_decrease_sat_noeeprom(void);
void rgblight_increase_val(void); void rgblight_increase_val(void);
void rgblight_increase_val_noeeprom(void);
void rgblight_decrease_val(void); void rgblight_decrease_val(void);
void rgblight_decrease_val_noeeprom(void);
void rgblight_increase_speed(void); void rgblight_increase_speed(void);
void rgblight_decrease_speed(void); void rgblight_decrease_speed(void);
void rgblight_sethsv(uint16_t hue, uint8_t sat, uint8_t val); void rgblight_sethsv(uint8_t hue, uint8_t sat, uint8_t val);
uint16_t rgblight_get_hue(void); void rgblight_sethsv_noeeprom(uint8_t hue, uint8_t sat, uint8_t val);
/* query */
uint8_t rgblight_get_mode(void);
uint8_t rgblight_get_hue(void);
uint8_t rgblight_get_sat(void); uint8_t rgblight_get_sat(void);
uint8_t rgblight_get_val(void); uint8_t rgblight_get_val(void);
void rgblight_setrgb(uint8_t r, uint8_t g, uint8_t b);
void rgblight_setrgb_at(uint8_t r, uint8_t g, uint8_t b, uint8_t index);
void rgblight_sethsv_at(uint16_t hue, uint8_t sat, uint8_t val, uint8_t index);
/* === qmk_firmware (core)internal Functions === */
void rgblight_init(void);
uint32_t rgblight_read_dword(void);
void rgblight_update_dword(uint32_t dword);
uint32_t eeconfig_read_rgblight(void); uint32_t eeconfig_read_rgblight(void);
void eeconfig_update_rgblight(uint32_t val); void eeconfig_update_rgblight(uint32_t val);
void eeconfig_update_rgblight_default(void); void eeconfig_update_rgblight_default(void);
@ -133,19 +251,9 @@ void eeconfig_debug_rgblight(void);
void rgb_matrix_increase(void); void rgb_matrix_increase(void);
void rgb_matrix_decrease(void); void rgb_matrix_decrease(void);
void sethsv(uint16_t hue, uint8_t sat, uint8_t val, LED_TYPE *led1); void rgblight_sethsv_eeprom_helper(uint8_t hue, uint8_t sat, uint8_t val, bool write_to_eeprom);
void setrgb(uint8_t r, uint8_t g, uint8_t b, LED_TYPE *led1);
void rgblight_sethsv_noeeprom(uint16_t hue, uint8_t sat, uint8_t val);
void rgblight_mode_noeeprom(uint8_t mode);
void rgblight_toggle_noeeprom(void);
void rgblight_enable_noeeprom(void);
void rgblight_disable_noeeprom(void);
void rgblight_sethsv_eeprom_helper(uint16_t hue, uint8_t sat, uint8_t val, bool write_to_eeprom);
void rgblight_mode_eeprom_helper(uint8_t mode, bool write_to_eeprom); void rgblight_mode_eeprom_helper(uint8_t mode, bool write_to_eeprom);
# define EZ_RGB(val) rgblight_show_solid_color((val >> 16) & 0xFF, (val >> 8) & 0xFF, val & 0xFF) # define EZ_RGB(val) rgblight_show_solid_color((val >> 16) & 0xFF, (val >> 8) & 0xFF, val & 0xFF)
void rgblight_show_solid_color(uint8_t r, uint8_t g, uint8_t b); void rgblight_show_solid_color(uint8_t r, uint8_t g, uint8_t b);
@ -155,12 +263,52 @@ void rgblight_timer_init(void);
void rgblight_timer_enable(void); void rgblight_timer_enable(void);
void rgblight_timer_disable(void); void rgblight_timer_disable(void);
void rgblight_timer_toggle(void); void rgblight_timer_toggle(void);
void rgblight_effect_breathing(uint8_t interval);
void rgblight_effect_rainbow_mood(uint8_t interval); # ifdef RGBLIGHT_SPLIT
void rgblight_effect_rainbow_swirl(uint8_t interval); # define RGBLIGHT_STATUS_CHANGE_MODE (1 << 0)
void rgblight_effect_snake(uint8_t interval); # define RGBLIGHT_STATUS_CHANGE_HSVS (1 << 1)
void rgblight_effect_knight(uint8_t interval); # define RGBLIGHT_STATUS_CHANGE_TIMER (1 << 2)
void rgblight_effect_christmas(void); # define RGBLIGHT_STATUS_ANIMATION_TICK (1 << 3)
void rgblight_effect_rgbtest(void);
typedef struct _rgblight_syncinfo_t {
rgblight_config_t config;
rgblight_status_t status;
} rgblight_syncinfo_t;
/* for split keyboard master side */
uint8_t rgblight_get_change_flags(void);
void rgblight_clear_change_flags(void);
void rgblight_get_syncinfo(rgblight_syncinfo_t *syncinfo);
/* for split keyboard slave side */
void rgblight_update_sync(rgblight_syncinfo_t *syncinfo, bool write_to_eeprom);
# endif
# ifdef RGBLIGHT_USE_TIMER
typedef struct _animation_status_t {
uint16_t last_timer;
uint8_t delta; /* mode - base_mode */
bool restart;
union {
uint16_t pos16;
uint8_t pos;
int8_t current_hue;
uint16_t current_offset;
};
} animation_status_t;
extern animation_status_t animation_status;
void rgblight_effect_breathing(animation_status_t *anim);
void rgblight_effect_rainbow_mood(animation_status_t *anim);
void rgblight_effect_rainbow_swirl(animation_status_t *anim);
void rgblight_effect_snake(animation_status_t *anim);
void rgblight_effect_knight(animation_status_t *anim);
void rgblight_effect_christmas(animation_status_t *anim);
void rgblight_effect_rgbtest(animation_status_t *anim);
void rgblight_effect_alternating(animation_status_t *anim);
# endif # endif
#endif // #ifndef RGBLIGHT_H_DUMMY_DEFINE
#endif // RGBLIGHT_H

6
keyboards/mxss/rules.mk
View File

@ -14,7 +14,7 @@ BOOTLOADER = atmel-dfu
# Build Options # Build Options
# change yes to no to disable # change yes to no to disable
# #
BOOTMAGIC_ENABLE = no # Virtual DIP switch configuration(+1000) BOOTMAGIC_ENABLE = lite # Virtual DIP switch configuration(+1000)
MOUSEKEY_ENABLE = yes # Mouse keys(+4700) MOUSEKEY_ENABLE = yes # 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)
@ -30,10 +30,12 @@ BLUETOOTH_ENABLE = no # Enable Bluetooth with the Adafruit EZ-Key HID
AUDIO_ENABLE = no # Audio output on port C6 AUDIO_ENABLE = no # Audio output on port C6
FAUXCLICKY_ENABLE = no # Use buzzer to emulate clicky switches FAUXCLICKY_ENABLE = no # Use buzzer to emulate clicky switches
SRC += mxss_frontled.c
# Remove the common RGB light code and use my iteration instead # Remove the common RGB light code and use my iteration instead
OPT_DEFS += -DRGBLIGHT_ENABLE OPT_DEFS += -DRGBLIGHT_ENABLE
SRC += $(QUANTUM_DIR)/process_keycode/process_rgb.c SRC += $(QUANTUM_DIR)/process_keycode/process_rgb.c
SRC += rgblight.c SRC += rgblight.c
SRC += color.c
SRC += ws2812.c SRC += ws2812.c
CIE1931_CURVE = yes CIE1931_CURVE = yes
LED_BREATHING_TABLE = yes

17
keyboards/mxss/templates/keymap.c
View File

@ -14,19 +14,20 @@
* 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 #include QMK_KEYBOARD_H
#include "mxss_frontled.h"
// Predefined colors for layers hs_set caps_color = { .hue = 0, .sat = 255 };
// Colors for layers
// Format: {hue, saturation} // Format: {hue, saturation}
// {0, 0} to turn off the LED // {0, 0} to turn off the LED
// Add additional rows to handle more layers // Add additional rows to handle more layers
hs_set layer_colors[] = { hs_set layer_colors[4] = {
[0] = {0, 0}, // Color for Layer 0 [0] = {.hue = 0, .sat = 0}, // Color for Layer 0
[1] = {86, 255}, // Color for Layer 1 [1] = {.hue = 86, .sat = 255}, // Color for Layer 1
[2] = {36, 255}, // Color for Layer 2 [2] = {.hue = 36, .sat = 255}, // Color for Layer 2
[3] = {185, 255}, // Color for Layer 3 [3] = {.hue = 185, .sat = 255}, // Color for Layer 3
}; };
const size_t lc_size = sizeof(layer_colors) / sizeof(uint16_t); size_t lc_size = sizeof(layer_colors) / sizeof(uint16_t);
// Use NEW_SAFE_RANGE to define new custom keycodes in order to not overwrite the ones used for front LED control // Use NEW_SAFE_RANGE to define new custom keycodes in order to not overwrite the ones used for front LED control
enum custom_keycodes { enum custom_keycodes {