7 years ago · f7ff3326e0
--- a/keyboard/nano/Makefile
+++ b/keyboard/nano/Makefile
@@ -0,0 +1,136 @@
 #----------------------------------------------------------------------------
 # On command line:
 #
 # make all = Make software.
 #
 # make clean = Clean out built project files.
 #
 # make coff = Convert ELF to AVR COFF.
 #
 # make extcoff = Convert ELF to AVR Extended COFF.
 #
 # make program = Download the hex file to the device.
 # Please customize your programmer settings(PROGRAM_CMD)
 #
 # make teensy = Download the hex file to the device, using teensy_loader_cli.
 # (must have teensy_loader_cli installed).
 #
 # make dfu = Download the hex file to the device, using dfu-programmer (must
 # have dfu-programmer installed).
 #
 # make flip = Download the hex file to the device, using Atmel FLIP (must
 # have Atmel FLIP installed).
 #
 # make dfu-ee = Download the eeprom file to the device, using dfu-programmer
 # (must have dfu-programmer installed).
 #
 # 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, 
 # with avr-gdb or avr-insight as the front end for debugging.
 #
 # make filename.s = Just compile filename.c into the assembler code only.
 #
 # make filename.i = Create a preprocessed source file for use in submitting
 # bug reports to the GCC project.
 #
 # To rebuild project do "make clean" then "make all".
 #----------------------------------------------------------------------------

 # Target file name (without extension).
 TARGET = nano

 # Directory common source filess exist
 TMK_DIR = ../../tmk_core

 # Directory keyboard dependent files exist
 TARGET_DIR = .

 # project specific files
 SRC = matrix.c \
 led.c \
 rgblight.c \
 light_ws2812.c

 ifdef KEYMAP
 SRC := keymap_$(KEYMAP).c $(SRC)
 else
 SRC := keymap_nano.c $(SRC)
 endif

 CONFIG_H = config.h


 # MCU name
 #MCU = at90usb1287
 MCU = atmega32u4

 # Processor frequency.
 # This will define a symbol, F_CPU, in all source code files equal to the
 # processor frequency in Hz. You can then use this symbol in your source code to
 # calculate timings. Do NOT tack on a 'UL' at the end, this will be done
 # automatically to create a 32-bit value in your source code.
 #
 # This will be an integer division of F_USB below, as it is sourced by
 # F_USB after it has run through any CPU prescalers. Note that this value
 # does not *change* the processor frequency - it should merely be updated to
 # reflect the processor speed set externally so that the code can use accurate
 # software delays.
 F_CPU = 16000000


 #
 # LUFA specific
 #
 # Target architecture (see library "Board Types" documentation).
 ARCH = AVR8

 # Input clock frequency.
 # This will define a symbol, F_USB, in all source code files equal to the
 # input clock frequency (before any prescaling is performed) in Hz. This value may
 # differ from F_CPU if prescaling is used on the latter, and is required as the
 # raw input clock is fed directly to the PLL sections of the AVR for high speed
 # clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
 # at the end, this will be done automatically to create a 32-bit value in your
 # source code.
 #
 # If no clock division is performed on the input clock inside the AVR (via the
 # CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
 F_USB = $(F_CPU)

 # Interrupt driven control endpoint task(+60)
 OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT


 # Boot Section Size in *bytes*
 # Teensy halfKay 512
 # Teensy++ halfKay 1024
 # Atmel DFU loader 4096
 # LUFA bootloader 4096
 # USBaspLoader 2048
 OPT_DEFS += -DBOOTLOADER_SIZE=4096


 # Build Options
 # comment out to disable the options.
 #
 BOOTMAGIC_ENABLE = yes # Virtual DIP switch configuration(+1000)
 #MOUSEKEY_ENABLE = yes # Mouse keys(+4700)
 EXTRAKEY_ENABLE = yes # Audio control and System control(+450)
 CONSOLE_ENABLE = yes # Console for debug(+400)
 COMMAND_ENABLE = yes # Commands for debug and configuration
 #SLEEP_LED_ENABLE = yes # Breathing sleep LED during USB suspend
 NKRO_ENABLE = yes # USB Nkey Rollover - not yet supported in LUFA


 # Optimize size but this may cause error "relocation truncated to fit"
 #EXTRALDFLAGS = -Wl,--relax

 # Search Path
 VPATH += $(TARGET_DIR)
 VPATH += $(TMK_DIR)

 include $(TMK_DIR)/protocol/lufa.mk
 include $(TMK_DIR)/common.mk
 include $(TMK_DIR)/rules.mk
--- a/keyboard/nano/config.h
+++ b/keyboard/nano/config.h
@@ -0,0 +1,83 @@
 /*
 Copyright 2012 Jun Wako <[email protected]>

 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/>.
 */

 #ifndef CONFIG_H
 #define CONFIG_H


 /* USB Device descriptor parameter */
 #define VENDOR_ID 0xFEED
 #define PRODUCT_ID 0x0A0C
 #define DEVICE_VER 0x00AA
 #define MANUFACTURER di0ib
 #define PRODUCT The Nano Keyboard
 #define DESCRIPTION A tactile switch keyboard

 /* key matrix size */
 #define MATRIX_ROWS 1
 #define MATRIX_COLS 8

 /* define if matrix has ghost */
 //#define MATRIX_HAS_GHOST

 /* Set 0 if debouncing isn't needed */
 #define DEBOUNCE 5

 /* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */
 #define LOCKING_SUPPORT_ENABLE
 /* Locking resynchronize hack */
 #define LOCKING_RESYNC_ENABLE

 /* key combination for command */
 #define IS_COMMAND() ( \
 keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) \
 )

 /* ws2812 RGB LED */
 #define ws2812_PORTREG PORTB
 #define ws2812_DDRREG DDRB
 #define ws2812_pin PB5
 #define RGBLED_NUM 3 // Number of LEDs
 #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

 /*
 * Feature disable options
 * These options are also useful to firmware size reduction.
 */

 /* disable debug print */
 //#define NO_DEBUG

 /* disable print */
 //#define NO_PRINT

 /* disable action features */
 //#define NO_ACTION_LAYER
 //#define NO_ACTION_TAPPING
 //#define NO_ACTION_ONESHOT
 //#define NO_ACTION_MACRO
 //#define NO_ACTION_FUNCTION

 #endif
--- a/keyboard/nano/keymap_common.h
+++ b/keyboard/nano/keymap_common.h
@@ -0,0 +1,42 @@
 /*
 Copyright 2012,2013 Jun Wako <[email protected]>

 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/>.
 */


 #ifndef KEYMAP_COMMON_H
 #define KEYMAP_COMMON_H

 #include <stdint.h>
 #include <stdbool.h>
 #include "keycode.h"
 #include "action.h"
 #include "action_macro.h"
 #include "report.h"
 #include "host.h"
 #include "print.h"
 #include "debug.h"
 #include "keymap.h"
 #include "rgblight.h"

 #define KEYMAP( \
 K00, K01, K02, K03, \
 K04, K05, K06, K07 \
 ) \
 { \
 { KC_##K00, KC_##K01, KC_##K02, KC_##K03, KC_##K04, KC_##K05, KC_##K06, KC_##K07 } \
 }

 #endif
--- a/keyboard/nano/keymap_nano.c
+++ b/keyboard/nano/keymap_nano.c
@@ -0,0 +1,84 @@
 #include "keymap_common.h"

 const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {

 KEYMAP(
 FN0, VOLD, MUTE, VOLU,
 MPRV, MPLY, MSTP, MNXT
 ),

 KEYMAP(
 TRNS, F2, F3, F4,
 F5, F6, F7, F8
 ),
 };

 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 action_t PROGMEM fn_actions[] = {
 [0] = ACTION_LAYER_TAP_KEY(1, KC_ESC),
 [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),
 };

 void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
 switch (id) {
 case RGBLED_TOGGLE:
 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;
 }
 }


--- a/keyboard/nano/led.c
+++ b/keyboard/nano/led.c
@@ -0,0 +1,38 @@
 /*
 Copyright 2012 Jun Wako <[email protected]>

 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 <avr/io.h>
 #include "stdint.h"
 #include "led.h"


 void led_set(uint8_t usb_led)
 {
 if (usb_led & (1<<USB_LED_CAPS_LOCK)) {
 // output low
 DDRB &= ~(1<<0);
 PORTB &= ~(1<<0);
 DDRD |= (1<<5);
 PORTD &= ~(1<<5);
 } else {
 // Hi-Z
 DDRB |= (1<<0);
 PORTB &= ~(1<<0);
 DDRD &= ~(1<<5);
 PORTD &= ~(1<<5);
 }
 }
--- a/keyboard/nano/light_ws2812.c
+++ b/keyboard/nano/light_ws2812.c
@@ -0,0 +1,181 @@
 /*
 * light weight WS2812 lib V2.0b
 *
 * Controls WS2811/WS2812/WS2812B RGB-LEDs
 * Author: Tim ([email protected])
 *
 * 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;
 }
--- a/keyboard/nano/light_ws2812.h
+++ b/keyboard/nano/light_ws2812.h
@@ -0,0 +1,73 @@
 /*
 * light weight WS2812 lib include
 *
 * Version 2.3 - Nev 29th 2015
 * Author: Tim ([email protected])
 *
 * 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�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_ */
--- a/keyboard/nano/matrix.c
+++ b/keyboard/nano/matrix.c
@@ -0,0 +1,179 @@
 /*
 Copyright 2012 Jun Wako <[email protected]>

 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/>.
 */

 /*
 * scan matrix
 */
 #include <stdint.h>
 #include <stdbool.h>
 #include <avr/io.h>
 #include <util/delay.h>
 #include "print.h"
 #include "debug.h"
 #include "util.h"
 #include "matrix.h"
 #include "rgblight.h"

 #ifndef DEBOUNCE
 # define DEBOUNCE 5
 #endif
 static uint8_t debouncing = DEBOUNCE;

 /* matrix state(1:on, 0:off) */
 static matrix_row_t matrix[MATRIX_ROWS];
 static matrix_row_t matrix_debouncing[MATRIX_ROWS];

 static matrix_row_t read_cols(void);
 static void init_cols(void);
 static void unselect_rows(void);
 static void select_row(uint8_t row);


 inline
 uint8_t matrix_rows(void)
 {
 return MATRIX_ROWS;
 }

 inline
 uint8_t matrix_cols(void)
 {
 return MATRIX_COLS;
 }

 void matrix_init(void)
 {
 // initialize row and col
 unselect_rows();
 init_cols();

 // initialize matrix state: all keys off
 for (uint8_t i=0; i < MATRIX_ROWS; i++) {
 matrix[i] = 0;
 matrix_debouncing[i] = 0;
 }
 
 rgblight_init();}

 uint8_t matrix_scan(void)
 {
 for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
 select_row(i);
 _delay_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 = DEBOUNCE;
 }
 unselect_rows();
 }

 if (debouncing) {
 if (--debouncing) {
 _delay_ms(1);
 } else {
 for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
 matrix[i] = matrix_debouncing[i];
 }
 }
 }

 return 1;
 }

 bool matrix_is_modified(void)
 {
 if (debouncing) return false;
 return true;
 }

 inline
 bool matrix_is_on(uint8_t row, uint8_t col)
 {
 return (matrix[row] & ((matrix_row_t)1<<col));
 }

 inline
 matrix_row_t matrix_get_row(uint8_t row)
 {
 return matrix[row];
 }

 void matrix_print(void)
 {
 print("\nr/c 0123456789ABCDEF\n");
 for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
 phex(row); print(": ");
 pbin_reverse16(matrix_get_row(row));
 print("\n");
 }
 }

 uint8_t matrix_key_count(void)
 {
 uint8_t count = 0;
 for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
 count += bitpop16(matrix[i]);
 }
 return count;
 }

 /* Column pin configuration
 * col: 0 1 2 3 4 5 6 7 
 * pin: F4 F5 F6 F7 D1 D0 D4 C6 
 */
 
 static void init_cols(void)
 {
 // Input with pull-up(DDR:0, PORT:1)
 DDRF &= ~(1<<4 | 1<<5 | 1<<6 | 1<<7);
 PORTF |= (1<<4 | 1<<5 | 1<<6 | 1<<7);
 DDRC &= ~(1<<6);
 PORTC |= (1<<6);
 DDRD &= ~(1<<0 | 1<<1 | 1<<4 );
 PORTD |= (1<<0 | 1<<1 | 1<<4 );
 }

 static matrix_row_t read_cols(void)
 {
 return (PINF&(1<<4) ? 0 : (1<<0)) |
 (PINF&(1<<5) ? 0 : (1<<1)) |
 (PINF&(1<<6) ? 0 : (1<<2)) |
 (PINF&(1<<7) ? 0 : (1<<3)) |
 (PIND&(1<<1) ? 0 : (1<<4)) |
 (PIND&(1<<0) ? 0 : (1<<5)) |
 (PIND&(1<<4) ? 0 : (1<<6)) |
 (PINC&(1<<6) ? 0 : (1<<7));
 }

 /* Row pin configuration
 * row: 
 * pin: 
 */
 
 static void unselect_rows(void)
 {
 // Hi-Z(DDR:0, PORT:0) to unselect
 }

 static void select_row(uint8_t row)
 {
 // Output low(DDR:1, PORT:0) to select
 }
--- a/keyboard/nano/pcb/nano.zip
+++ b/keyboard/nano/pcb/nano.zip
--- a/keyboard/nano/pcb/readme.md
+++ b/keyboard/nano/pcb/readme.md
@@ -0,0 +1,16 @@
 EasyEDA ordering info:

 34.3mm Max* 17.8mm Max;
 Layers: 2;
 PCB Thickness: 1.6mm;
 PCB Qty.: 30;
 PCB Color: Green;
 Surface Finish: HASL;
 Copper Weight: 1;
 Panelized PCBs: 1



 Gerber files released under https://creativecommons.org/licenses/by-sa/4.0/

 ![Creative Commons Attribution-ShareAlike 4.0 International License](https://i.creativecommons.org/l/by-sa/4.0/88x31.png)
--- a/keyboard/nano/rgblight.c
+++ b/keyboard/nano/rgblight.c
@@ -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 = 13;
 } 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;
 }
 }

 }
--- a/keyboard/nano/rgblight.h
+++ b/keyboard/nano/rgblight.h
@@ -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 11
 #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