Merge pull request #106 from yangliu/planck-rgb
RGB Underglow with WS2812 LEDs
This commit is contained in:
Jack Humbert
commit
99c72d0d9b
52
README.md
52
README.md
|
|
@ -73,7 +73,7 @@ The following shortcuts automatically add `LSFT()` to keycodes to get commonly u
|
|||
KC_PIPE |
|
||||
KC_COLN :
|
||||
|
||||
`MT(mod, kc)` - is *mod* (modifier key - MOD_LCTL, MOD_LSFT) when held, and *kc* when tapped. In other words, you can have a key that sends Esc (or the letter O or whatever) when you tap it, but works as a Control key or a Shift key when you hold it down.
|
||||
`MT(mod, kc)` - is *mod* (modifier key - MOD_LCTL, MOD_LSFT) when held, and *kc* when tapped. In other words, you can have a key that sends Esc (or the letter O or whatever) when you tap it, but works as a Control key or a Shift key when you hold it down.
|
||||
|
||||
These are the values you can use for the `mod` in `MT()` (right-hand modifiers are not available):
|
||||
|
||||
|
|
@ -86,15 +86,15 @@ These can also be combined like `MOD_LCTL | MOD_LSFT` e.g. `MT(MOD_LCTL | MOD_LS
|
|||
|
||||
We've added shortcuts to make common modifier/tap (mod-tap) mappings more compact:
|
||||
|
||||
* `CTL_T(kc)` - is LCTL when held and *kc* when tapped
|
||||
* `SFT_T(kc)` - is LSFT when held and *kc* when tapped
|
||||
* `ALT_T(kc)` - is LALT when held and *kc* when tapped
|
||||
* `GUI_T(kc)` - is LGUI when held and *kc* when tapped
|
||||
* `CTL_T(kc)` - is LCTL when held and *kc* when tapped
|
||||
* `SFT_T(kc)` - is LSFT when held and *kc* when tapped
|
||||
* `ALT_T(kc)` - is LALT when held and *kc* when tapped
|
||||
* `GUI_T(kc)` - is LGUI when held and *kc* when tapped
|
||||
* `ALL_T(kc)` - is Hyper (all mods) when held and *kc* when tapped. To read more about what you can do with a Hyper key, see [this blog post by Brett Terpstra](http://brettterpstra.com/2012/12/08/a-useful-caps-lock-key/)
|
||||
* `LCAG_T(kc)` - is CtrlAltGui when held and *kc* when tapped
|
||||
* `MEH_T(kc)` - is like Hyper, but not as cool -- does not include the Cmd/Win key, so just sends Alt+Ctrl+Shift.
|
||||
|
||||
### Temporarily setting the default layer
|
||||
### Temporarily setting the default layer
|
||||
|
||||
`DF(layer)` - sets default layer to *layer*. The default layer is the one at the "bottom" of the layer stack - the ultimate fallback layer. This currently does not persist over power loss. When you plug the keyboard back in, layer 0 will always be the default. It is theoretically possible to work around that, but that's not what `DF` does.
|
||||
|
||||
|
|
@ -115,7 +115,7 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) //
|
|||
case 0: // this would trigger when you hit a key mapped as M(0)
|
||||
if (record->event.pressed) {
|
||||
return MACRO( I(255), T(H), T(E), T(L), T(L), W(255), T(O), END ); // this sends the string 'hello' when the macro executes
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
return MACRO_NONE;
|
||||
|
|
@ -141,11 +141,11 @@ Everything is assuming you're in Qwerty (in software) by default, but there is b
|
|||
#include "keymap_<layout>.h"
|
||||
|
||||
Where <layout> is "colemak" or "dvorak". After including this line, you will get access to:
|
||||
|
||||
|
||||
* `CM_*` for all of the Colemak-equivalent characters
|
||||
* `DV_*` for all of the Dvorak-equivalent characters
|
||||
|
||||
These implementations assume you're using Colemak or Dvorak on your OS, not on your keyboard - this is referred to as a software-implemented layout. If your computer is in Qwerty and your keymap is in Colemak or Dvorak, this is referred to as a firmware-implemented layout, and you won't need these features.
|
||||
|
||||
These implementations assume you're using Colemak or Dvorak on your OS, not on your keyboard - this is referred to as a software-implemented layout. If your computer is in Qwerty and your keymap is in Colemak or Dvorak, this is referred to as a firmware-implemented layout, and you won't need these features.
|
||||
|
||||
To give an example, if you're using software-implemented Colemak, and want to get an `F`, you would use `CM_F` - `KC_F` under these same circumstances would result in `T`.
|
||||
|
||||
|
|
@ -188,7 +188,7 @@ The method does not require Unicode support in the keyboard itself but depends i
|
|||
First you need to select a modifier combination that is not in use by any of your programs.
|
||||
CtrlAltWin is not used very widely and should therefore be perfect for this.
|
||||
There is a macro defined for a mod-tab combo `LCAG_T`.
|
||||
Add this mod-tab combo to a key on your keyboard, e.g.: `LCAG_T(KC_TAB)`.
|
||||
Add this mod-tab combo to a key on your keyboard, e.g.: `LCAG_T(KC_TAB)`.
|
||||
This makes the key behave like a tab key if pressed and released immediately but changes it to the modifier if used with another key.
|
||||
|
||||
In the default script of AutoHotkey you can define custom hotkeys.
|
||||
|
|
@ -198,3 +198,33 @@ In the default script of AutoHotkey you can define custom hotkeys.
|
|||
|
||||
The hotkeys above are for the combination CtrlAltGui and CtrlAltGuiShift plus the letter a.
|
||||
AutoHotkey inserts the Text right of `Send, ` when this combination is pressed.
|
||||
|
||||
## RGB Under Glow Mod
|
||||
|
||||
|
||||
|
||||
Here is a quick demo on Youtube (with NPKC KC60) (https://www.youtube.com/watch?v=VKrpPAHlisY).
|
||||
|
||||
For this mod, you need an unused pin wiring to DI of WS2812 strip. After wiring the VCC, GND, and DI, you can enable the underglow in your Makefile.
|
||||
|
||||
RGBLIGHT_ENABLE = yes
|
||||
|
||||
Please note that the underglow is not compatible with MIDI functions. So you cannot enable both of them at the same time.
|
||||
|
||||
Please add the following options into your config.h, and set them up according your hardware configuration.
|
||||
|
||||
#define ws2812_PORTREG PORTF
|
||||
#define ws2812_DDRREG DDRF
|
||||
#define ws2812_pin PF4
|
||||
#define RGBLED_NUM 14 // Number of LEDs
|
||||
#define RGBLIGHT_HUE_STEP 10
|
||||
#define RGBLIGHT_SAT_STEP 17
|
||||
#define RGBLIGHT_VAL_STEP 17
|
||||
|
||||
The firmware supports 5 different light effects, and the color (hue, saturation, brightness) can be customized in most effects. To control the underglow, you need to modify your keymap file to assign those functions to some keys/key combinations. For details, please check this keymap. `keyboard/planck/keymaps/yang/keymap.c`
|
||||
|
||||
### WS2812 Wiring
|
||||
|
||||
|
||||
|
||||
Please note the USB port can only supply a limited amount of power to the keyboard (500mA by standard, however, modern computer and most usb hubs can provide 700+mA.). According to the data of NeoPixel from Adafruit, 30 WS2812 LEDs require a 5V 1A power supply, LEDs used in this mod should not more than 20.
|
||||
|
|
|
|||
|
|
@ -27,7 +27,7 @@
|
|||
# make flip-ee = Download the eeprom file to the device, using Atmel FLIP
|
||||
# (must have Atmel FLIP installed).
|
||||
#
|
||||
# make debug = Start either simulavr or avarice as specified for debugging,
|
||||
# make debug = Start either simulavr or avarice as specified for debugging,
|
||||
# with avr-gdb or avr-insight as the front end for debugging.
|
||||
#
|
||||
# make filename.s = Just compile filename.c into the assembler code only.
|
||||
|
|
@ -143,11 +143,13 @@ BACKLIGHT_ENABLE = yes # Enable keyboard backlight functionality
|
|||
# AUDIO_ENABLE = YES # Audio output on port C6
|
||||
# UNICODE_ENABLE = YES # Unicode
|
||||
# BLUETOOTH_ENABLE = yes # Enable Bluetooth with the Adafruit EZ-Key HID
|
||||
# RGBLIGHT_ENABLE = yes # Enable WS2812 RGB underlight. Do not enable this with MIDI at the same time.
|
||||
|
||||
ifdef BACKLIGHT_ENABLE
|
||||
SRC += backlight.c
|
||||
endif
|
||||
|
||||
|
||||
# Optimize size but this may cause error "relocation truncated to fit"
|
||||
#EXTRALDFLAGS = -Wl,--relax
|
||||
|
||||
|
|
@ -157,4 +159,3 @@ VPATH += $(TOP_DIR)
|
|||
VPATH += $(TMK_DIR)
|
||||
|
||||
include $(TOP_DIR)/quantum/quantum.mk
|
||||
|
||||
|
|
|
|||
|
|
@ -58,6 +58,15 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|||
keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) \
|
||||
)
|
||||
|
||||
/* ws2812 RGB LED */
|
||||
#define ws2812_PORTREG PORTD
|
||||
#define ws2812_DDRREG DDRD
|
||||
#define ws2812_pin PD1
|
||||
#define RGBLED_NUM 28 // Number of LEDs
|
||||
#define RGBLIGHT_HUE_STEP 10
|
||||
#define RGBLIGHT_SAT_STEP 17
|
||||
#define RGBLIGHT_VAL_STEP 17
|
||||
|
||||
/*
|
||||
* Feature disable options
|
||||
* These options are also useful to firmware size reduction.
|
||||
|
|
|
|||
Binary file not shown.
|
After Width: | Height: | Size: 284 KiB |
|
|
@ -0,0 +1,146 @@
|
|||
// This is the canonical layout file for the Quantum project. If you want to add another keyboard,
|
||||
// this is the style you want to emulate.
|
||||
|
||||
#include "planck.h"
|
||||
#ifdef BACKLIGHT_ENABLE
|
||||
#include "backlight.h"
|
||||
#endif
|
||||
|
||||
// Each layer gets a name for readability, which is then used in the keymap matrix below.
|
||||
// The underscores don't mean anything - you can have a layer called STUFF or any other name.
|
||||
// Layer names don't all need to be of the same length, obviously, and you can also skip them
|
||||
// entirely and just use numbers.
|
||||
#define _QW 0
|
||||
#define _CM 1
|
||||
#define _DV 2
|
||||
#define _LW 3
|
||||
#define _RS 4
|
||||
#define _RGB 5
|
||||
|
||||
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
|
||||
[_QW] = { /* Qwerty */
|
||||
{KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_BSPC},
|
||||
{KC_ESC, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT},
|
||||
{KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_ENT },
|
||||
{M(0), KC_LCTL, KC_LALT, KC_LGUI, MO(_LW), F(0), F(0), MO(_RS), KC_LEFT, KC_DOWN, KC_UP, KC_RGHT}
|
||||
},
|
||||
[_CM] = { /* Colemak */
|
||||
{KC_TAB, KC_Q, KC_W, KC_F, KC_P, KC_G, KC_J, KC_L, KC_U, KC_Y, KC_SCLN, KC_BSPC},
|
||||
{KC_ESC, KC_A, KC_R, KC_S, KC_T, KC_D, KC_H, KC_N, KC_E, KC_I, KC_O, KC_QUOT},
|
||||
{KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_K, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_ENT },
|
||||
{M(0), KC_LCTL, KC_LALT, KC_LGUI, MO(_LW), F(0), F(0), MO(_RS), KC_LEFT, KC_DOWN, KC_UP, KC_RGHT}
|
||||
},
|
||||
[_DV] = { /* Dvorak */
|
||||
{KC_TAB, KC_QUOT, KC_COMM, KC_DOT, KC_P, KC_Y, KC_F, KC_G, KC_C, KC_R, KC_L, KC_BSPC},
|
||||
{KC_ESC, KC_A, KC_O, KC_E, KC_U, KC_I, KC_D, KC_H, KC_T, KC_N, KC_S, KC_SLSH},
|
||||
{KC_LSFT, KC_SCLN, KC_Q, KC_J, KC_K, KC_X, KC_B, KC_M, KC_W, KC_V, KC_Z, KC_ENT },
|
||||
{M(0), KC_LCTL, KC_LALT, KC_LGUI, MO(_LW), F(0), F(0), MO(_RS), KC_LEFT, KC_DOWN, KC_UP, KC_RGHT}
|
||||
},
|
||||
[_RS] = { /* RAISE */
|
||||
{KC_GRV, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_BSPC},
|
||||
{KC_TRNS, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_MINS, KC_EQL, KC_LBRC, KC_RBRC, KC_BSLS},
|
||||
{KC_TRNS, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, DF(_QW), DF(_CM), DF(_DV), RESET, KC_TRNS},
|
||||
{KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY}
|
||||
},
|
||||
[_LW] = { /* LOWER */
|
||||
{KC_TILD, KC_EXLM, KC_AT, KC_HASH, KC_DLR, KC_PERC, KC_CIRC, KC_AMPR, KC_ASTR, KC_LPRN, KC_RPRN, KC_BSPC},
|
||||
{KC_TRNS, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_UNDS, KC_PLUS, KC_LCBR, KC_RCBR, KC_PIPE},
|
||||
{KC_TRNS, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, DF(_QW), DF(_CM), DF(_DV), RESET, KC_TRNS},
|
||||
{KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY}
|
||||
},
|
||||
[_RGB] = { /* RGBLIGHT */
|
||||
{KC_TRNS, KC_PGUP, KC_UP, KC_PGDN, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_DEL},
|
||||
{KC_TRNS, KC_LEFT, KC_DOWN, KC_RGHT, KC_TRNS, KC_HOME, KC_LEFT, KC_DOWN, KC_UP, KC_RGHT, KC_END, KC_TRNS},
|
||||
{KC_TRNS, F(1), F(2), F(3), F(4), F(5), F(6), F(7), F(8), KC_TRNS, KC_TRNS, KC_TRNS},
|
||||
{KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS}
|
||||
|
||||
}
|
||||
};
|
||||
|
||||
enum function_id {
|
||||
RGBLED_TOGGLE,
|
||||
RGBLED_STEP_MODE,
|
||||
RGBLED_INCREASE_HUE,
|
||||
RGBLED_DECREASE_HUE,
|
||||
RGBLED_INCREASE_SAT,
|
||||
RGBLED_DECREASE_SAT,
|
||||
RGBLED_INCREASE_VAL,
|
||||
RGBLED_DECREASE_VAL,
|
||||
};
|
||||
|
||||
const uint16_t PROGMEM fn_actions[] = {
|
||||
[0] = ACTION_LAYER_TAP_KEY(_RGB, KC_SPC),
|
||||
[1] = ACTION_FUNCTION(RGBLED_TOGGLE),
|
||||
[2] = ACTION_FUNCTION(RGBLED_STEP_MODE),
|
||||
[3] = ACTION_FUNCTION(RGBLED_INCREASE_HUE),
|
||||
[4] = ACTION_FUNCTION(RGBLED_DECREASE_HUE),
|
||||
[5] = ACTION_FUNCTION(RGBLED_INCREASE_SAT),
|
||||
[6] = ACTION_FUNCTION(RGBLED_DECREASE_SAT),
|
||||
[7] = ACTION_FUNCTION(RGBLED_INCREASE_VAL),
|
||||
[8] = ACTION_FUNCTION(RGBLED_DECREASE_VAL),
|
||||
};
|
||||
|
||||
const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
|
||||
{
|
||||
// MACRODOWN only works in this function
|
||||
switch(id) {
|
||||
case 0:
|
||||
if (record->event.pressed) {
|
||||
register_code(KC_RSFT);
|
||||
#ifdef BACKLIGHT_ENABLE
|
||||
backlight_step();
|
||||
#endif
|
||||
} else {
|
||||
unregister_code(KC_RSFT);
|
||||
}
|
||||
break;
|
||||
}
|
||||
return MACRO_NONE;
|
||||
};
|
||||
|
||||
void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
|
||||
switch (id) {
|
||||
case RGBLED_TOGGLE:
|
||||
//led operations
|
||||
if (record->event.pressed) {
|
||||
rgblight_toggle();
|
||||
}
|
||||
|
||||
break;
|
||||
case RGBLED_INCREASE_HUE:
|
||||
if (record->event.pressed) {
|
||||
rgblight_increase_hue();
|
||||
}
|
||||
break;
|
||||
case RGBLED_DECREASE_HUE:
|
||||
if (record->event.pressed) {
|
||||
rgblight_decrease_hue();
|
||||
}
|
||||
break;
|
||||
case RGBLED_INCREASE_SAT:
|
||||
if (record->event.pressed) {
|
||||
rgblight_increase_sat();
|
||||
}
|
||||
break;
|
||||
case RGBLED_DECREASE_SAT:
|
||||
if (record->event.pressed) {
|
||||
rgblight_decrease_sat();
|
||||
}
|
||||
break;
|
||||
case RGBLED_INCREASE_VAL:
|
||||
if (record->event.pressed) {
|
||||
rgblight_increase_val();
|
||||
}
|
||||
break;
|
||||
case RGBLED_DECREASE_VAL:
|
||||
if (record->event.pressed) {
|
||||
rgblight_decrease_val();
|
||||
}
|
||||
break;
|
||||
case RGBLED_STEP_MODE:
|
||||
if (record->event.pressed) {
|
||||
rgblight_step();
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 335 KiB |
|
|
@ -15,6 +15,11 @@ void * matrix_init_kb(void) {
|
|||
backlight_init_ports();
|
||||
#endif
|
||||
|
||||
#ifdef RGBLIGHT_ENABLE
|
||||
rgblight_init();
|
||||
#endif
|
||||
|
||||
|
||||
// Turn status LED on
|
||||
DDRE |= (1<<6);
|
||||
PORTE |= (1<<6);
|
||||
|
|
@ -28,4 +33,4 @@ void * matrix_scan_kb(void) {
|
|||
if (matrix_scan_user) {
|
||||
(*matrix_scan_user)();
|
||||
}
|
||||
};
|
||||
};
|
||||
|
|
|
|||
|
|
@ -6,6 +6,9 @@
|
|||
#ifdef BACKLIGHT_ENABLE
|
||||
#include "backlight.h"
|
||||
#endif
|
||||
#ifdef RGBLIGHT_ENABLE
|
||||
#include "rgblight.h"
|
||||
#endif
|
||||
#include <stddef.h>
|
||||
#ifdef MIDI_ENABLE
|
||||
#include <keymap_midi.h>
|
||||
|
|
@ -22,7 +25,7 @@
|
|||
{ k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k1a, k1b }, \
|
||||
{ k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k2a, k2b }, \
|
||||
{ k30, k31, k32, k33, k34, k35, k35, k37, k38, k39, k3a, k3b } \
|
||||
}
|
||||
}
|
||||
|
||||
#define PLANCK_GRID( \
|
||||
k00, k01, k02, k03, k04, k05, k06, k07, k08, k09, k0a, k0b, \
|
||||
|
|
@ -35,9 +38,9 @@
|
|||
{ k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k1a, k1b }, \
|
||||
{ k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k2a, k2b }, \
|
||||
{ k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k3a, k3b } \
|
||||
}
|
||||
}
|
||||
|
||||
void * matrix_init_user(void);
|
||||
void * matrix_scan_user(void);
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -0,0 +1,181 @@
|
|||
/*
|
||||
* light weight WS2812 lib V2.0b
|
||||
*
|
||||
* Controls WS2811/WS2812/WS2812B RGB-LEDs
|
||||
* Author: Tim (cpldcpu@gmail.com)
|
||||
*
|
||||
* Jan 18th, 2014 v2.0b Initial Version
|
||||
* Nov 29th, 2015 v2.3 Added SK6812RGBW support
|
||||
*
|
||||
* License: GNU GPL v2 (see License.txt)
|
||||
*/
|
||||
|
||||
#include "light_ws2812.h"
|
||||
#include <avr/interrupt.h>
|
||||
#include <avr/io.h>
|
||||
#include <util/delay.h>
|
||||
#include "debug.h"
|
||||
|
||||
// Setleds for standard RGB
|
||||
void inline ws2812_setleds(struct cRGB *ledarray, uint16_t leds)
|
||||
{
|
||||
ws2812_setleds_pin(ledarray,leds, _BV(ws2812_pin));
|
||||
}
|
||||
|
||||
void inline ws2812_setleds_pin(struct cRGB *ledarray, uint16_t leds, uint8_t pinmask)
|
||||
{
|
||||
ws2812_DDRREG |= pinmask; // Enable DDR
|
||||
ws2812_sendarray_mask((uint8_t*)ledarray,leds+leds+leds,pinmask);
|
||||
_delay_us(50);
|
||||
}
|
||||
|
||||
// Setleds for SK6812RGBW
|
||||
void inline ws2812_setleds_rgbw(struct cRGBW *ledarray, uint16_t leds)
|
||||
{
|
||||
ws2812_DDRREG |= _BV(ws2812_pin); // Enable DDR
|
||||
ws2812_sendarray_mask((uint8_t*)ledarray,leds<<2,_BV(ws2812_pin));
|
||||
_delay_us(80);
|
||||
}
|
||||
|
||||
void ws2812_sendarray(uint8_t *data,uint16_t datlen)
|
||||
{
|
||||
ws2812_sendarray_mask(data,datlen,_BV(ws2812_pin));
|
||||
}
|
||||
|
||||
/*
|
||||
This routine writes an array of bytes with RGB values to the Dataout pin
|
||||
using the fast 800kHz clockless WS2811/2812 protocol.
|
||||
*/
|
||||
|
||||
// Timing in ns
|
||||
#define w_zeropulse 350
|
||||
#define w_onepulse 900
|
||||
#define w_totalperiod 1250
|
||||
|
||||
// Fixed cycles used by the inner loop
|
||||
#define w_fixedlow 2
|
||||
#define w_fixedhigh 4
|
||||
#define w_fixedtotal 8
|
||||
|
||||
// Insert NOPs to match the timing, if possible
|
||||
#define w_zerocycles (((F_CPU/1000)*w_zeropulse )/1000000)
|
||||
#define w_onecycles (((F_CPU/1000)*w_onepulse +500000)/1000000)
|
||||
#define w_totalcycles (((F_CPU/1000)*w_totalperiod +500000)/1000000)
|
||||
|
||||
// w1 - nops between rising edge and falling edge - low
|
||||
#define w1 (w_zerocycles-w_fixedlow)
|
||||
// w2 nops between fe low and fe high
|
||||
#define w2 (w_onecycles-w_fixedhigh-w1)
|
||||
// w3 nops to complete loop
|
||||
#define w3 (w_totalcycles-w_fixedtotal-w1-w2)
|
||||
|
||||
#if w1>0
|
||||
#define w1_nops w1
|
||||
#else
|
||||
#define w1_nops 0
|
||||
#endif
|
||||
|
||||
// The only critical timing parameter is the minimum pulse length of the "0"
|
||||
// Warn or throw error if this timing can not be met with current F_CPU settings.
|
||||
#define w_lowtime ((w1_nops+w_fixedlow)*1000000)/(F_CPU/1000)
|
||||
#if w_lowtime>550
|
||||
#error "Light_ws2812: Sorry, the clock speed is too low. Did you set F_CPU correctly?"
|
||||
#elif w_lowtime>450
|
||||
#warning "Light_ws2812: The timing is critical and may only work on WS2812B, not on WS2812(S)."
|
||||
#warning "Please consider a higher clockspeed, if possible"
|
||||
#endif
|
||||
|
||||
#if w2>0
|
||||
#define w2_nops w2
|
||||
#else
|
||||
#define w2_nops 0
|
||||
#endif
|
||||
|
||||
#if w3>0
|
||||
#define w3_nops w3
|
||||
#else
|
||||
#define w3_nops 0
|
||||
#endif
|
||||
|
||||
#define w_nop1 "nop \n\t"
|
||||
#define w_nop2 "rjmp .+0 \n\t"
|
||||
#define w_nop4 w_nop2 w_nop2
|
||||
#define w_nop8 w_nop4 w_nop4
|
||||
#define w_nop16 w_nop8 w_nop8
|
||||
|
||||
void inline ws2812_sendarray_mask(uint8_t *data,uint16_t datlen,uint8_t maskhi)
|
||||
{
|
||||
uint8_t curbyte,ctr,masklo;
|
||||
uint8_t sreg_prev;
|
||||
|
||||
masklo =~maskhi&ws2812_PORTREG;
|
||||
maskhi |= ws2812_PORTREG;
|
||||
sreg_prev=SREG;
|
||||
cli();
|
||||
|
||||
while (datlen--) {
|
||||
curbyte=*data++;
|
||||
|
||||
asm volatile(
|
||||
" ldi %0,8 \n\t"
|
||||
"loop%=: \n\t"
|
||||
" out %2,%3 \n\t" // '1' [01] '0' [01] - re
|
||||
#if (w1_nops&1)
|
||||
w_nop1
|
||||
#endif
|
||||
#if (w1_nops&2)
|
||||
w_nop2
|
||||
#endif
|
||||
#if (w1_nops&4)
|
||||
w_nop4
|
||||
#endif
|
||||
#if (w1_nops&8)
|
||||
w_nop8
|
||||
#endif
|
||||
#if (w1_nops&16)
|
||||
w_nop16
|
||||
#endif
|
||||
" sbrs %1,7 \n\t" // '1' [03] '0' [02]
|
||||
" out %2,%4 \n\t" // '1' [--] '0' [03] - fe-low
|
||||
" lsl %1 \n\t" // '1' [04] '0' [04]
|
||||
#if (w2_nops&1)
|
||||
w_nop1
|
||||
#endif
|
||||
#if (w2_nops&2)
|
||||
w_nop2
|
||||
#endif
|
||||
#if (w2_nops&4)
|
||||
w_nop4
|
||||
#endif
|
||||
#if (w2_nops&8)
|
||||
w_nop8
|
||||
#endif
|
||||
#if (w2_nops&16)
|
||||
w_nop16
|
||||
#endif
|
||||
" out %2,%4 \n\t" // '1' [+1] '0' [+1] - fe-high
|
||||
#if (w3_nops&1)
|
||||
w_nop1
|
||||
#endif
|
||||
#if (w3_nops&2)
|
||||
w_nop2
|
||||
#endif
|
||||
#if (w3_nops&4)
|
||||
w_nop4
|
||||
#endif
|
||||
#if (w3_nops&8)
|
||||
w_nop8
|
||||
#endif
|
||||
#if (w3_nops&16)
|
||||
w_nop16
|
||||
#endif
|
||||
|
||||
" dec %0 \n\t" // '1' [+2] '0' [+2]
|
||||
" brne loop%=\n\t" // '1' [+3] '0' [+4]
|
||||
: "=&d" (ctr)
|
||||
: "r" (curbyte), "I" (_SFR_IO_ADDR(ws2812_PORTREG)), "r" (maskhi), "r" (masklo)
|
||||
);
|
||||
}
|
||||
|
||||
SREG=sreg_prev;
|
||||
}
|
||||
|
|
@ -0,0 +1,73 @@
|
|||
/*
|
||||
* light weight WS2812 lib include
|
||||
*
|
||||
* Version 2.3 - Nev 29th 2015
|
||||
* Author: Tim (cpldcpu@gmail.com)
|
||||
*
|
||||
* Please do not change this file! All configuration is handled in "ws2812_config.h"
|
||||
*
|
||||
* License: GNU GPL v2 (see License.txt)
|
||||
+
|
||||
*/
|
||||
|
||||
#ifndef LIGHT_WS2812_H_
|
||||
#define LIGHT_WS2812_H_
|
||||
|
||||
#include <avr/io.h>
|
||||
#include <avr/interrupt.h>
|
||||
//#include "ws2812_config.h"
|
||||
|
||||
/*
|
||||
* Structure of the LED array
|
||||
*
|
||||
* cRGB: RGB for WS2812S/B/C/D, SK6812, SK6812Mini, SK6812WWA, APA104, APA106
|
||||
* cRGBW: RGBW for SK6812RGBW
|
||||
*/
|
||||
|
||||
struct cRGB { uint8_t g; uint8_t r; uint8_t b; };
|
||||
struct cRGBW { uint8_t g; uint8_t r; uint8_t b; uint8_t w;};
|
||||
|
||||
|
||||
|
||||
/* User Interface
|
||||
*
|
||||
* Input:
|
||||
* ledarray: An array of GRB data describing the LED colors
|
||||
* number_of_leds: The number of LEDs to write
|
||||
* pinmask (optional): Bitmask describing the output bin. e.g. _BV(PB0)
|
||||
*
|
||||
* The functions will perform the following actions:
|
||||
* - Set the data-out pin as output
|
||||
* - Send out the LED data
|
||||
* - Wait 50<EFBFBD>s to reset the LEDs
|
||||
*/
|
||||
|
||||
void ws2812_setleds (struct cRGB *ledarray, uint16_t number_of_leds);
|
||||
void ws2812_setleds_pin (struct cRGB *ledarray, uint16_t number_of_leds,uint8_t pinmask);
|
||||
void ws2812_setleds_rgbw(struct cRGBW *ledarray, uint16_t number_of_leds);
|
||||
|
||||
/*
|
||||
* Old interface / Internal functions
|
||||
*
|
||||
* The functions take a byte-array and send to the data output as WS2812 bitstream.
|
||||
* The length is the number of bytes to send - three per LED.
|
||||
*/
|
||||
|
||||
void ws2812_sendarray (uint8_t *array,uint16_t length);
|
||||
void ws2812_sendarray_mask(uint8_t *array,uint16_t length, uint8_t pinmask);
|
||||
|
||||
|
||||
/*
|
||||
* Internal defines
|
||||
*/
|
||||
#ifndef CONCAT
|
||||
#define CONCAT(a, b) a ## b
|
||||
#endif
|
||||
#ifndef CONCAT_EXP
|
||||
#define CONCAT_EXP(a, b) CONCAT(a, b)
|
||||
#endif
|
||||
|
||||
// #define ws2812_PORTREG CONCAT_EXP(PORT,ws2812_port)
|
||||
// #define ws2812_DDRREG CONCAT_EXP(DDR,ws2812_port)
|
||||
|
||||
#endif /* LIGHT_WS2812_H_ */
|
||||
|
|
@ -2,7 +2,7 @@ QUANTUM_DIR = quantum
|
|||
|
||||
# # project specific files
|
||||
SRC += $(QUANTUM_DIR)/keymap_common.c \
|
||||
$(QUANTUM_DIR)/led.c
|
||||
$(QUANTUM_DIR)/led.c
|
||||
|
||||
# ifdef KEYMAP_FILE
|
||||
# ifneq (,$(shell grep USING_MIDI '$(KEYMAP_FILE)'))
|
||||
|
|
@ -35,6 +35,12 @@ ifdef UNICODE_ENABLE
|
|||
SRC += $(QUANTUM_DIR)/keymap_unicode.c
|
||||
endif
|
||||
|
||||
ifdef RGBLIGHT_ENABLE
|
||||
SRC += $(QUANTUM_DIR)/light_ws2812.c
|
||||
SRC += $(QUANTUM_DIR)/rgblight.c
|
||||
OPT_DEFS += -DRGBLIGHT_ENABLE
|
||||
endif
|
||||
|
||||
# Optimize size but this may cause error "relocation truncated to fit"
|
||||
#EXTRALDFLAGS = -Wl,--relax
|
||||
|
||||
|
|
@ -45,4 +51,3 @@ include $(TMK_DIR)/protocol/lufa.mk
|
|||
|
||||
include $(TMK_DIR)/common.mk
|
||||
include $(TMK_DIR)/rules.mk
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,505 @@
|
|||
#include <avr/eeprom.h>
|
||||
#include <avr/interrupt.h>
|
||||
#include <util/delay.h>
|
||||
#include "progmem.h"
|
||||
#include "timer.h"
|
||||
#include "rgblight.h"
|
||||
#include "debug.h"
|
||||
|
||||
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,
|
||||
};
|
||||
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,37,40,42,44,47,49,52,54,57,59,62,65,67,70,73,76,79,82,85,88,90,93,97,100,103,106,109,112,115,118,121,124,127,131,134,137,140,143,146,149,152,155,158,162,165,167,170,173,176,179,182,185,188,190,193,196,198,201,203,206,208,211,213,215,218,220,222,224,226,228,230,232,234,235,237,238,240,241,243,244,245,246,248,249,250,250,251,252,253,253,254,254,254,255,255,255,255,255,255,255,254,254,254,253,253,252,251,250,250,249,248,246,245,244,243,241,240,238,237,235,234,232,230,228,226,224,222,220,218,215,213,211,208,206,203,201,198,196,193,190,188,185,182,179,176,173,170,167,165,162,158,155,152,149,146,143,140,137,134,131,128,124,121,118,115,112,109,106,103,100,97,93,90,88,85,82,79,76,73,70,67,65,62,59,57,54,52,49,47,44,42,40,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};
|
||||
const uint8_t RGBLED_BREATHING_INTERVALS[] PROGMEM = {30, 20, 10, 5};
|
||||
const uint8_t RGBLED_RAINBOW_MOOD_INTERVALS[] PROGMEM = {120, 60, 30};
|
||||
const uint8_t RGBLED_RAINBOW_SWIRL_INTERVALS[] PROGMEM = {100, 50, 20};
|
||||
const uint8_t RGBLED_SNAKE_INTERVALS[] PROGMEM = {100, 50, 20};
|
||||
const uint8_t RGBLED_KNIGHT_INTERVALS[] PROGMEM = {100, 50, 20};
|
||||
|
||||
rgblight_config_t rgblight_config;
|
||||
rgblight_config_t inmem_config;
|
||||
struct cRGB led[RGBLED_NUM];
|
||||
uint8_t rgblight_inited = 0;
|
||||
|
||||
|
||||
void sethsv(uint16_t hue, uint8_t sat, uint8_t val, struct cRGB *led1) {
|
||||
/* convert hue, saturation and brightness ( HSB/HSV ) to RGB
|
||||
The DIM_CURVE is used only on brightness/value and on saturation (inverted).
|
||||
This looks the most natural.
|
||||
*/
|
||||
uint8_t r, g, b;
|
||||
|
||||
val = pgm_read_byte(&DIM_CURVE[val]);
|
||||
sat = 255 - pgm_read_byte(&DIM_CURVE[255 - sat]);
|
||||
|
||||
uint8_t base;
|
||||
|
||||
if (sat == 0) { // Acromatic color (gray). Hue doesn't mind.
|
||||
r = val;
|
||||
g = val;
|
||||
b = val;
|
||||
} else {
|
||||
base = ((255 - sat) * val) >> 8;
|
||||
|
||||
switch (hue / 60) {
|
||||
case 0:
|
||||
r = val;
|
||||
g = (((val - base)*hue) / 60) + base;
|
||||
b = base;
|
||||
break;
|
||||
|
||||
case 1:
|
||||
r = (((val - base)*(60 - (hue % 60))) / 60) + base;
|
||||
g = val;
|
||||
b = base;
|
||||
break;
|
||||
|
||||
case 2:
|
||||
r = base;
|
||||
g = val;
|
||||
b = (((val - base)*(hue % 60)) / 60) + base;
|
||||
break;
|
||||
|
||||
case 3:
|
||||
r = base;
|
||||
g = (((val - base)*(60 - (hue % 60))) / 60) + base;
|
||||
b = val;
|
||||
break;
|
||||
|
||||
case 4:
|
||||
r = (((val - base)*(hue % 60)) / 60) + base;
|
||||
g = base;
|
||||
b = val;
|
||||
break;
|
||||
|
||||
case 5:
|
||||
r = val;
|
||||
g = base;
|
||||
b = (((val - base)*(60 - (hue % 60))) / 60) + base;
|
||||
break;
|
||||
}
|
||||
}
|
||||
setrgb(r,g,b, led1);
|
||||
}
|
||||
|
||||
void setrgb(uint8_t r, uint8_t g, uint8_t b, struct cRGB *led1) {
|
||||
(*led1).r = r;
|
||||
(*led1).g = g;
|
||||
(*led1).b = b;
|
||||
}
|
||||
|
||||
|
||||
uint32_t eeconfig_read_rgblight(void) {
|
||||
return eeprom_read_dword(EECONFIG_RGBLIGHT);
|
||||
}
|
||||
void eeconfig_write_rgblight(uint32_t val) {
|
||||
eeprom_write_dword(EECONFIG_RGBLIGHT, val);
|
||||
}
|
||||
void eeconfig_write_rgblight_default(void) {
|
||||
dprintf("eeconfig_write_rgblight_default\n");
|
||||
rgblight_config.enable = 1;
|
||||
rgblight_config.mode = 1;
|
||||
rgblight_config.hue = 200;
|
||||
rgblight_config.sat = 204;
|
||||
rgblight_config.val = 204;
|
||||
eeconfig_write_rgblight(rgblight_config.raw);
|
||||
}
|
||||
void eeconfig_debug_rgblight(void) {
|
||||
dprintf("rgblight_config eprom\n");
|
||||
dprintf("rgblight_config.enable = %d\n", rgblight_config.enable);
|
||||
dprintf("rghlight_config.mode = %d\n", rgblight_config.mode);
|
||||
dprintf("rgblight_config.hue = %d\n", rgblight_config.hue);
|
||||
dprintf("rgblight_config.sat = %d\n", rgblight_config.sat);
|
||||
dprintf("rgblight_config.val = %d\n", rgblight_config.val);
|
||||
}
|
||||
|
||||
void rgblight_init(void) {
|
||||
debug_enable = 1; // Debug ON!
|
||||
dprintf("rgblight_init called.\n");
|
||||
rgblight_inited = 1;
|
||||
dprintf("rgblight_init start!\n");
|
||||
if (!eeconfig_is_enabled()) {
|
||||
dprintf("rgblight_init eeconfig is not enabled.\n");
|
||||
eeconfig_init();
|
||||
eeconfig_write_rgblight_default();
|
||||
}
|
||||
rgblight_config.raw = eeconfig_read_rgblight();
|
||||
if (!rgblight_config.mode) {
|
||||
dprintf("rgblight_init rgblight_config.mode = 0. Write default values to EEPROM.\n");
|
||||
eeconfig_write_rgblight_default();
|
||||
rgblight_config.raw = eeconfig_read_rgblight();
|
||||
}
|
||||
eeconfig_debug_rgblight(); // display current eeprom values
|
||||
|
||||
rgblight_timer_init(); // setup the timer
|
||||
|
||||
if (rgblight_config.enable) {
|
||||
rgblight_mode(rgblight_config.mode);
|
||||
}
|
||||
}
|
||||
|
||||
void rgblight_increase(void) {
|
||||
uint8_t mode;
|
||||
if (rgblight_config.mode < RGBLIGHT_MODES) {
|
||||
mode = rgblight_config.mode + 1;
|
||||
}
|
||||
rgblight_mode(mode);
|
||||
}
|
||||
|
||||
void rgblight_decrease(void) {
|
||||
uint8_t mode;
|
||||
if (rgblight_config.mode > 1) { //mode will never < 1, if mode is less than 1, eeprom need to be initialized.
|
||||
mode = rgblight_config.mode-1;
|
||||
}
|
||||
rgblight_mode(mode);
|
||||
}
|
||||
|
||||
void rgblight_step(void) {
|
||||
uint8_t mode;
|
||||
mode = rgblight_config.mode + 1;
|
||||
if (mode > RGBLIGHT_MODES) {
|
||||
mode = 1;
|
||||
}
|
||||
rgblight_mode(mode);
|
||||
}
|
||||
|
||||
void rgblight_mode(uint8_t mode) {
|
||||
if (!rgblight_config.enable) {
|
||||
return;
|
||||
}
|
||||
if (mode<1) {
|
||||
rgblight_config.mode = 1;
|
||||
} else if (mode > RGBLIGHT_MODES) {
|
||||
rgblight_config.mode = RGBLIGHT_MODES;
|
||||
} else {
|
||||
rgblight_config.mode = mode;
|
||||
}
|
||||
eeconfig_write_rgblight(rgblight_config.raw);
|
||||
dprintf("rgblight mode: %u\n", rgblight_config.mode);
|
||||
if (rgblight_config.mode == 1) {
|
||||
rgblight_timer_disable();
|
||||
} else if (rgblight_config.mode >=2 && rgblight_config.mode <=23) {
|
||||
// MODE 2-5, breathing
|
||||
// MODE 6-8, rainbow mood
|
||||
// MODE 9-14, rainbow swirl
|
||||
// MODE 15-20, snake
|
||||
// MODE 21-23, knight
|
||||
rgblight_timer_enable();
|
||||
}
|
||||
rgblight_sethsv(rgblight_config.hue, rgblight_config.sat, rgblight_config.val);
|
||||
}
|
||||
|
||||
void rgblight_toggle(void) {
|
||||
rgblight_config.enable ^= 1;
|
||||
eeconfig_write_rgblight(rgblight_config.raw);
|
||||
dprintf("rgblight toggle: rgblight_config.enable = %u\n", rgblight_config.enable);
|
||||
if (rgblight_config.enable) {
|
||||
rgblight_mode(rgblight_config.mode);
|
||||
} else {
|
||||
rgblight_timer_disable();
|
||||
_delay_ms(50);
|
||||
rgblight_set();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void rgblight_increase_hue(void){
|
||||
uint16_t hue;
|
||||
hue = (rgblight_config.hue+RGBLIGHT_HUE_STEP) % 360;
|
||||
rgblight_sethsv(hue, rgblight_config.sat, rgblight_config.val);
|
||||
}
|
||||
void rgblight_decrease_hue(void){
|
||||
uint16_t hue;
|
||||
if (rgblight_config.hue-RGBLIGHT_HUE_STEP <0 ) {
|
||||
hue = (rgblight_config.hue+360-RGBLIGHT_HUE_STEP) % 360;
|
||||
} else {
|
||||
hue = (rgblight_config.hue-RGBLIGHT_HUE_STEP) % 360;
|
||||
}
|
||||
rgblight_sethsv(hue, rgblight_config.sat, rgblight_config.val);
|
||||
}
|
||||
void rgblight_increase_sat(void) {
|
||||
uint8_t sat;
|
||||
if (rgblight_config.sat + RGBLIGHT_SAT_STEP > 255) {
|
||||
sat = 255;
|
||||
} else {
|
||||
sat = rgblight_config.sat+RGBLIGHT_SAT_STEP;
|
||||
}
|
||||
rgblight_sethsv(rgblight_config.hue, sat, rgblight_config.val);
|
||||
}
|
||||
void rgblight_decrease_sat(void){
|
||||
uint8_t sat;
|
||||
if (rgblight_config.sat - RGBLIGHT_SAT_STEP < 0) {
|
||||
sat = 0;
|
||||
} else {
|
||||
sat = rgblight_config.sat-RGBLIGHT_SAT_STEP;
|
||||
}
|
||||
rgblight_sethsv(rgblight_config.hue, sat, rgblight_config.val);
|
||||
}
|
||||
void rgblight_increase_val(void){
|
||||
uint8_t val;
|
||||
if (rgblight_config.val + RGBLIGHT_VAL_STEP > 255) {
|
||||
val = 255;
|
||||
} else {
|
||||
val = rgblight_config.val+RGBLIGHT_VAL_STEP;
|
||||
}
|
||||
rgblight_sethsv(rgblight_config.hue, rgblight_config.sat, val);
|
||||
}
|
||||
void rgblight_decrease_val(void) {
|
||||
uint8_t val;
|
||||
if (rgblight_config.val - RGBLIGHT_VAL_STEP < 0) {
|
||||
val = 0;
|
||||
} else {
|
||||
val = rgblight_config.val-RGBLIGHT_VAL_STEP;
|
||||
}
|
||||
rgblight_sethsv(rgblight_config.hue, rgblight_config.sat, val);
|
||||
}
|
||||
|
||||
void rgblight_sethsv_noeeprom(uint16_t hue, uint8_t sat, uint8_t val){
|
||||
inmem_config.raw = rgblight_config.raw;
|
||||
if (rgblight_config.enable) {
|
||||
struct cRGB tmp_led;
|
||||
sethsv(hue, sat, val, &tmp_led);
|
||||
inmem_config.hue = hue;
|
||||
inmem_config.sat = sat;
|
||||
inmem_config.val = val;
|
||||
// dprintf("rgblight set hue [MEMORY]: %u,%u,%u\n", inmem_config.hue, inmem_config.sat, inmem_config.val);
|
||||
rgblight_setrgb(tmp_led.r, tmp_led.g, tmp_led.b);
|
||||
}
|
||||
}
|
||||
void rgblight_sethsv(uint16_t hue, uint8_t sat, uint8_t val){
|
||||
if (rgblight_config.enable) {
|
||||
if (rgblight_config.mode == 1) {
|
||||
// same static color
|
||||
rgblight_sethsv_noeeprom(hue, sat, val);
|
||||
} else {
|
||||
// all LEDs in same color
|
||||
if (rgblight_config.mode >= 2 && rgblight_config.mode <= 5) {
|
||||
// breathing mode, ignore the change of val, use in memory value instead
|
||||
val = rgblight_config.val;
|
||||
} else if (rgblight_config.mode >= 6 && rgblight_config.mode <= 14) {
|
||||
// rainbow mood and rainbow swirl, ignore the change of hue
|
||||
hue = rgblight_config.hue;
|
||||
}
|
||||
}
|
||||
rgblight_config.hue = hue;
|
||||
rgblight_config.sat = sat;
|
||||
rgblight_config.val = val;
|
||||
eeconfig_write_rgblight(rgblight_config.raw);
|
||||
dprintf("rgblight set hsv [EEPROM]: %u,%u,%u\n", rgblight_config.hue, rgblight_config.sat, rgblight_config.val);
|
||||
}
|
||||
}
|
||||
|
||||
void rgblight_setrgb(uint8_t r, uint8_t g, uint8_t b){
|
||||
// dprintf("rgblight set rgb: %u,%u,%u\n", r,g,b);
|
||||
for (uint8_t i=0;i<RGBLED_NUM;i++) {
|
||||
led[i].r = r;
|
||||
led[i].g = g;
|
||||
led[i].b = b;
|
||||
}
|
||||
rgblight_set();
|
||||
|
||||
}
|
||||
|
||||
void rgblight_set(void) {
|
||||
if (rgblight_config.enable) {
|
||||
ws2812_setleds(led, RGBLED_NUM);
|
||||
} else {
|
||||
for (uint8_t i=0;i<RGBLED_NUM;i++) {
|
||||
led[i].r = 0;
|
||||
led[i].g = 0;
|
||||
led[i].b = 0;
|
||||
}
|
||||
ws2812_setleds(led, RGBLED_NUM);
|
||||
}
|
||||
}
|
||||
|
||||
// Animation timer -- AVR Timer3
|
||||
void rgblight_timer_init(void) {
|
||||
static uint8_t rgblight_timer_is_init = 0;
|
||||
if (rgblight_timer_is_init) {
|
||||
return;
|
||||
}
|
||||
rgblight_timer_is_init = 1;
|
||||
/* Timer 3 setup */
|
||||
TCCR3B = _BV(WGM32) //CTC mode OCR3A as TOP
|
||||
| _BV(CS30); //Clock selelct: clk/1
|
||||
/* Set TOP value */
|
||||
uint8_t sreg = SREG;
|
||||
cli();
|
||||
OCR3AH = (RGBLED_TIMER_TOP>>8)&0xff;
|
||||
OCR3AL = RGBLED_TIMER_TOP&0xff;
|
||||
SREG = sreg;
|
||||
}
|
||||
void rgblight_timer_enable(void) {
|
||||
TIMSK3 |= _BV(OCIE3A);
|
||||
dprintf("TIMER3 enabled.\n");
|
||||
}
|
||||
void rgblight_timer_disable(void) {
|
||||
TIMSK3 &= ~_BV(OCIE3A);
|
||||
dprintf("TIMER3 disabled.\n");
|
||||
}
|
||||
void rgblight_timer_toggle(void) {
|
||||
TIMSK3 ^= _BV(OCIE3A);
|
||||
dprintf("TIMER3 toggled.\n");
|
||||
}
|
||||
|
||||
ISR(TIMER3_COMPA_vect) {
|
||||
// Mode = 1, static light, do nothing here
|
||||
if (rgblight_config.mode>=2 && rgblight_config.mode<=5) {
|
||||
// mode = 2 to 5, breathing mode
|
||||
rgblight_effect_breathing(rgblight_config.mode-2);
|
||||
|
||||
} else if (rgblight_config.mode>=6 && rgblight_config.mode<=8) {
|
||||
rgblight_effect_rainbow_mood(rgblight_config.mode-6);
|
||||
} else if (rgblight_config.mode>=9 && rgblight_config.mode<=14) {
|
||||
rgblight_effect_rainbow_swirl(rgblight_config.mode-9);
|
||||
} else if (rgblight_config.mode>=15 && rgblight_config.mode<=20) {
|
||||
rgblight_effect_snake(rgblight_config.mode-15);
|
||||
} else if (rgblight_config.mode>=21 && rgblight_config.mode<=23) {
|
||||
rgblight_effect_knight(rgblight_config.mode-21);
|
||||
}
|
||||
}
|
||||
|
||||
// effects
|
||||
void rgblight_effect_breathing(uint8_t interval) {
|
||||
static uint8_t pos = 0;
|
||||
static uint16_t last_timer = 0;
|
||||
|
||||
if (timer_elapsed(last_timer)<pgm_read_byte(&RGBLED_BREATHING_INTERVALS[interval])) return;
|
||||
last_timer = timer_read();
|
||||
|
||||
rgblight_sethsv_noeeprom(rgblight_config.hue, rgblight_config.sat, pgm_read_byte(&RGBLED_BREATHING_TABLE[pos]));
|
||||
pos = (pos+1) % 256;
|
||||
}
|
||||
|
||||
void rgblight_effect_rainbow_mood(uint8_t interval) {
|
||||
static uint16_t current_hue=0;
|
||||
static uint16_t last_timer = 0;
|
||||
|
||||
if (timer_elapsed(last_timer)<pgm_read_byte(&RGBLED_RAINBOW_MOOD_INTERVALS[interval])) return;
|
||||
last_timer = timer_read();
|
||||
rgblight_sethsv_noeeprom(current_hue, rgblight_config.sat, rgblight_config.val);
|
||||
current_hue = (current_hue+1) % 360;
|
||||
}
|
||||
|
||||
void rgblight_effect_rainbow_swirl(uint8_t interval) {
|
||||
static uint16_t current_hue=0;
|
||||
static uint16_t last_timer = 0;
|
||||
uint16_t hue;
|
||||
uint8_t i;
|
||||
if (timer_elapsed(last_timer)<pgm_read_byte(&RGBLED_RAINBOW_MOOD_INTERVALS[interval/2])) return;
|
||||
last_timer = timer_read();
|
||||
for (i=0; i<RGBLED_NUM; i++) {
|
||||
hue = (360/RGBLED_NUM*i+current_hue)%360;
|
||||
sethsv(hue, rgblight_config.sat, rgblight_config.val, &led[i]);
|
||||
}
|
||||
rgblight_set();
|
||||
|
||||
if (interval % 2) {
|
||||
current_hue = (current_hue+1) % 360;
|
||||
} else {
|
||||
if (current_hue -1 < 0) {
|
||||
current_hue = 359;
|
||||
} else {
|
||||
current_hue = current_hue - 1;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
void rgblight_effect_snake(uint8_t interval) {
|
||||
static uint8_t pos=0;
|
||||
static uint16_t last_timer = 0;
|
||||
uint8_t i,j;
|
||||
int8_t k;
|
||||
int8_t increament = 1;
|
||||
if (interval%2) increament = -1;
|
||||
if (timer_elapsed(last_timer)<pgm_read_byte(&RGBLED_SNAKE_INTERVALS[interval/2])) return;
|
||||
last_timer = timer_read();
|
||||
for (i=0;i<RGBLED_NUM;i++) {
|
||||
led[i].r=0;
|
||||
led[i].g=0;
|
||||
led[i].b=0;
|
||||
for (j=0;j<RGBLIGHT_EFFECT_SNAKE_LENGTH;j++) {
|
||||
k = pos+j*increament;
|
||||
if (k<0) k = k+RGBLED_NUM;
|
||||
if (i==k) {
|
||||
sethsv(rgblight_config.hue, rgblight_config.sat, (uint8_t)(rgblight_config.val*(RGBLIGHT_EFFECT_SNAKE_LENGTH-j)/RGBLIGHT_EFFECT_SNAKE_LENGTH), &led[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
rgblight_set();
|
||||
if (increament == 1) {
|
||||
if (pos - 1 < 0) {
|
||||
pos = RGBLED_NUM-1;
|
||||
} else {
|
||||
pos -= 1;
|
||||
}
|
||||
} else {
|
||||
pos = (pos+1)%RGBLED_NUM;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
void rgblight_effect_knight(uint8_t interval) {
|
||||
static int8_t pos=0;
|
||||
static uint16_t last_timer = 0;
|
||||
uint8_t i,j,cur;
|
||||
int8_t k;
|
||||
struct cRGB preled[RGBLED_NUM];
|
||||
static int8_t increament = -1;
|
||||
if (timer_elapsed(last_timer)<pgm_read_byte(&RGBLED_KNIGHT_INTERVALS[interval])) return;
|
||||
last_timer = timer_read();
|
||||
for (i=0;i<RGBLED_NUM;i++) {
|
||||
preled[i].r=0;
|
||||
preled[i].g=0;
|
||||
preled[i].b=0;
|
||||
for (j=0;j<RGBLIGHT_EFFECT_KNIGHT_LENGTH;j++) {
|
||||
k = pos+j*increament;
|
||||
if (k<0) k = 0;
|
||||
if (k>=RGBLED_NUM) k=RGBLED_NUM-1;
|
||||
if (i==k) {
|
||||
sethsv(rgblight_config.hue, rgblight_config.sat, rgblight_config.val, &preled[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (RGBLIGHT_EFFECT_KNIGHT_OFFSET) {
|
||||
for (i=0;i<RGBLED_NUM;i++) {
|
||||
cur = (i+RGBLIGHT_EFFECT_KNIGHT_OFFSET) % RGBLED_NUM;
|
||||
led[i].r = preled[cur].r;
|
||||
led[i].g = preled[cur].g;
|
||||
led[i].b = preled[cur].b;
|
||||
}
|
||||
}
|
||||
rgblight_set();
|
||||
if (increament == 1) {
|
||||
if (pos - 1 < 0 - RGBLIGHT_EFFECT_KNIGHT_LENGTH) {
|
||||
pos = 0- RGBLIGHT_EFFECT_KNIGHT_LENGTH;
|
||||
increament = -1;
|
||||
} else {
|
||||
pos -= 1;
|
||||
}
|
||||
} else {
|
||||
if (pos+1>RGBLED_NUM+RGBLIGHT_EFFECT_KNIGHT_LENGTH) {
|
||||
pos = RGBLED_NUM+RGBLIGHT_EFFECT_KNIGHT_LENGTH-1;
|
||||
increament = 1;
|
||||
} else {
|
||||
pos += 1;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,87 @@
|
|||
#ifndef RGBLIGHT_H
|
||||
#define RGBLIGHT_H
|
||||
|
||||
#ifndef RGBLIGHT_MODES
|
||||
#define RGBLIGHT_MODES 23
|
||||
#endif
|
||||
|
||||
#ifndef RGBLIGHT_EFFECT_SNAKE_LENGTH
|
||||
#define RGBLIGHT_EFFECT_SNAKE_LENGTH 7
|
||||
#endif
|
||||
|
||||
#ifndef RGBLIGHT_EFFECT_KNIGHT_LENGTH
|
||||
#define RGBLIGHT_EFFECT_KNIGHT_LENGTH 7
|
||||
#endif
|
||||
#ifndef RGBLIGHT_EFFECT_KNIGHT_OFFSET
|
||||
#define RGBLIGHT_EFFECT_KNIGHT_OFFSET 9
|
||||
#endif
|
||||
|
||||
#ifndef RGBLIGHT_EFFECT_DUALKNIGHT_LENGTH
|
||||
#define RGBLIGHT_EFFECT_DUALKNIGHT_LENGTH 4
|
||||
#endif
|
||||
|
||||
#ifndef RGBLIGHT_HUE_STEP
|
||||
#define RGBLIGHT_HUE_STEP 10
|
||||
#endif
|
||||
#ifndef RGBLIGHT_SAT_STEP
|
||||
#define RGBLIGHT_SAT_STEP 17
|
||||
#endif
|
||||
#ifndef RGBLIGHT_VAL_STEP
|
||||
#define RGBLIGHT_VAL_STEP 17
|
||||
#endif
|
||||
|
||||
#define RGBLED_TIMER_TOP F_CPU/(256*64)
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
#include "eeconfig.h"
|
||||
#include "light_ws2812.h"
|
||||
|
||||
typedef union {
|
||||
uint32_t raw;
|
||||
struct {
|
||||
bool enable :1;
|
||||
uint8_t mode :6;
|
||||
uint16_t hue :9;
|
||||
uint8_t sat :8;
|
||||
uint8_t val :8;
|
||||
};
|
||||
} rgblight_config_t;
|
||||
|
||||
void rgblight_init(void);
|
||||
void rgblight_increase(void);
|
||||
void rgblight_decrease(void);
|
||||
void rgblight_toggle(void);
|
||||
void rgblight_step(void);
|
||||
void rgblight_mode(uint8_t mode);
|
||||
void rgblight_set(void);
|
||||
void rgblight_increase_hue(void);
|
||||
void rgblight_decrease_hue(void);
|
||||
void rgblight_increase_sat(void);
|
||||
void rgblight_decrease_sat(void);
|
||||
void rgblight_increase_val(void);
|
||||
void rgblight_decrease_val(void);
|
||||
void rgblight_sethsv(uint16_t hue, uint8_t sat, uint8_t val);
|
||||
void rgblight_setrgb(uint8_t r, uint8_t g, uint8_t b);
|
||||
|
||||
#define EECONFIG_RGBLIGHT (uint8_t *)7
|
||||
uint32_t eeconfig_read_rgblight(void);
|
||||
void eeconfig_write_rgblight(uint32_t val);
|
||||
void eeconfig_write_rgblight_default(void);
|
||||
void eeconfig_debug_rgblight(void);
|
||||
|
||||
void sethsv(uint16_t hue, uint8_t sat, uint8_t val, struct cRGB *led1);
|
||||
void setrgb(uint8_t r, uint8_t g, uint8_t b, struct cRGB *led1);
|
||||
void rgblight_sethsv_noeeprom(uint16_t hue, uint8_t sat, uint8_t val);
|
||||
|
||||
void rgblight_timer_init(void);
|
||||
void rgblight_timer_enable(void);
|
||||
void rgblight_timer_disable(void);
|
||||
void rgblight_timer_toggle(void);
|
||||
void rgblight_effect_breathing(uint8_t interval);
|
||||
void rgblight_effect_rainbow_mood(uint8_t interval);
|
||||
void rgblight_effect_rainbow_swirl(uint8_t interval);
|
||||
void rgblight_effect_snake(uint8_t interval);
|
||||
void rgblight_effect_knight(uint8_t interval);
|
||||
|
||||
#endif
|
||||
Loading…
Reference in New Issue