docs/feature_rgb_matrix.md

   1 # RGB Matrix Lighting
   2
   3 ## Driver configuration
   4
   5 ### IS31FL3731
   6
   7 There is basic support for addressable RGB matrix lighting with the I2C IS31FL3731 RGB controller. To enable it, add this to your `rules.mk`:
   8
   9     RGB_MATRIX_ENABLE = IS31FL3731
  10
  11 Configure the hardware via your `config.h`:
  12
  13         // This is a 7-bit address, that gets left-shifted and bit 0
  14         // set to 0 for write, 1 for read (as per I2C protocol)
  15         // The address will vary depending on your wiring:
  16         // 0b1110100 AD <-> GND
  17         // 0b1110111 AD <-> VCC
  18         // 0b1110101 AD <-> SCL
  19         // 0b1110110 AD <-> SDA
  20         #define DRIVER_ADDR_1 0b1110100
  21         #define DRIVER_ADDR_2 0b1110110
  22
  23         #define DRIVER_COUNT 2
  24         #define DRIVER_1_LED_TOTAL 25
  25         #define DRIVER_2_LED_TOTAL 24
  26         #define DRIVER_LED_TOTAL DRIVER_1_LED_TOTAL + DRIVER_2_LED_TOTAL
  27
  28 Currently only 2 drivers are supported, but it would be trivial to support all 4 combinations.
  29
  30 Define these arrays listing all the LEDs in your `<keyboard>.c`:
  31
  32         const is31_led g_is31_leds[DRIVER_LED_TOTAL] = {
  33         /* Refer to IS31 manual for these locations
  34          *   driver
  35          *   |  R location
  36          *   |  |      G location
  37          *   |  |      |      B location
  38          *   |  |      |      | */
  39             {0, C1_3,  C2_3,  C3_3},
  40             ....
  41         }
  42
  43 Where `Cx_y` is the location of the LED in the matrix defined by [the datasheet](http://www.issi.com/WW/pdf/31FL3731.pdf) and the header file `drivers/issi/is31fl3731.h`. The `driver` is the index of the driver you defined in your `config.h` (`0` or `1` right now).
  44
  45 ###  IS31FL3733
  46
  47 There is basic support for addressable RGB matrix lighting with the I2C IS31FL3733 RGB controller. To enable it, add this to your `rules.mk`:
  48
  49     RGB_MATRIX_ENABLE = IS31FL3733
  50
  51 Configure the hardware via your `config.h`:
  52
  53         // This is a 7-bit address, that gets left-shifted and bit 0
  54         // set to 0 for write, 1 for read (as per I2C protocol)
  55         // The address will vary depending on your wiring:
  56         // 00 <-> GND
  57         // 01 <-> SCL
  58         // 10 <-> SDA
  59         // 11 <-> VCC
  60         // ADDR1 represents A1:A0 of the 7-bit address.
  61         // ADDR2 represents A3:A2 of the 7-bit address.
  62         // The result is: 0b101(ADDR2)(ADDR1)
  63         #define DRIVER_ADDR_1 0b1010000
  64         #define DRIVER_ADDR_2 0b1010000 // this is here for compliancy reasons.
  65
  66         #define DRIVER_COUNT 1
  67         #define DRIVER_1_LED_TOTAL 64
  68         #define DRIVER_LED_TOTAL DRIVER_1_LED_TOTAL
  69
  70 Currently only a single drivers is supported, but it would be trivial to support all 4 combinations. For now define `DRIVER_ADDR_2` as `DRIVER_ADDR_1`
  71
  72 Define these arrays listing all the LEDs in your `<keyboard>.c`:
  73
  74         const is31_led g_is31_leds[DRIVER_LED_TOTAL] = {
  75         /* Refer to IS31 manual for these locations
  76          *   driver
  77          *   |  R location
  78          *   |  |       G location
  79          *   |  |       |       B location
  80          *   |  |       |       | */
  81             {0, B_1,    A_1,    C_1},
  82             ....
  83         }
  84
  85 Where `X_Y` is the location of the LED in the matrix defined by [the datasheet](http://www.issi.com/WW/pdf/31FL3733.pdf) and the header file `drivers/issi/is31fl3733.h`. The `driver` is the index of the driver you defined in your `config.h` (Only `0` right now).
  86
  87 From this point forward the configuration is the same for all the drivers.
  88
  89         const rgb_led g_rgb_leds[DRIVER_LED_TOTAL] = {
  90         /* {row | col << 4}
  91          *    |           {x=0..224, y=0..64}
  92          *    |              |               modifier
  93          *    |              |                 | */
  94             {{0|(0<<4)},   {20.36*0, 21.33*0}, 1},
  95             {{0|(1<<4)},   {20.36*1, 21.33*0}, 1},
  96             ....
  97         }
  98
  99 The format for the matrix position used in this array is `{row | (col << 4)}`. The `x` is between (inclusive) 0-224, and `y` is between (inclusive) 0-64. The easiest way to calculate these positions is:
 100
 101     x = 224 / ( NUMBER_OF_ROWS - 1 ) * ROW_POSITION
 102     y = 64 / (NUMBER_OF_COLS - 1 ) * COL_POSITION
 103
 104 Where all variables are decimels/floats.
 105
 106 `modifier` is a boolean, whether or not a certain key is considered a modifier (used in some effects).
 107
 108 ## Keycodes
 109
 110 All RGB keycodes are currently shared with the RGBLIGHT system:
 111
 112         * `RGB_TOG` - toggle
 113         * `RGB_MOD` - cycle through modes
 114         * `RGB_HUI` - increase hue
 115         * `RGB_HUD` - decrease hue
 116         * `RGB_SAI` - increase saturation
 117         * `RGB_SAD` - decrease saturation
 118         * `RGB_VAI` - increase value
 119         * `RGB_VAD` - decrease value
 120         * `RGB_SPI` - increase speed effect (no EEPROM support)
 121         * `RGB_SPD` - decrease speed effect (no EEPROM support)
 122
 123
 124         * `RGB_MODE_*` keycodes will generally work, but are not currently mapped to the correct effects for the RGB Matrix system
 125
 126 ## RGB Matrix Effects
 127
 128 These are the effects that are currently available:
 129
 130         enum rgb_matrix_effects {
 131             RGB_MATRIX_SOLID_COLOR = 1,
 132             RGB_MATRIX_ALPHAS_MODS,
 133             RGB_MATRIX_DUAL_BEACON,
 134             RGB_MATRIX_GRADIENT_UP_DOWN,
 135             RGB_MATRIX_RAINDROPS,
 136             RGB_MATRIX_CYCLE_ALL,
 137             RGB_MATRIX_CYCLE_LEFT_RIGHT,
 138             RGB_MATRIX_CYCLE_UP_DOWN,
 139             RGB_MATRIX_RAINBOW_BEACON,
 140             RGB_MATRIX_RAINBOW_PINWHEELS,
 141             RGB_MATRIX_RAINBOW_MOVING_CHEVRON,
 142             RGB_MATRIX_JELLYBEAN_RAINDROPS,
 143             RGB_MATRIX_DIGITAL_RAIN,
 144         #ifdef RGB_MATRIX_KEYPRESSES
 145             RGB_MATRIX_SOLID_REACTIVE,
 146             RGB_MATRIX_SPLASH,
 147             RGB_MATRIX_MULTISPLASH,
 148             RGB_MATRIX_SOLID_SPLASH,
 149             RGB_MATRIX_SOLID_MULTISPLASH,
 150         #endif
 151             RGB_MATRIX_EFFECT_MAX
 152         };
 153
 154 You can disable a single effect by defining `DISABLE_[EFFECT_NAME]` in your `config.h`:
 155
 156
 157 |Define                                             |Description                                 |
 158 |---------------------------------------------------|--------------------------------------------|
 159 |`#define DISABLE_RGB_MATRIX_ALPHAS_MODS`           |Disables `RGB_MATRIX_ALPHAS_MODS`           |
 160 |`#define DISABLE_RGB_MATRIX_DUAL_BEACON`           |Disables `RGB_MATRIX_DUAL_BEACON`           |
 161 |`#define DISABLE_RGB_MATRIX_GRADIENT_UP_DOWN`      |Disables `RGB_MATRIX_GRADIENT_UP_DOWN`      |
 162 |`#define DISABLE_RGB_MATRIX_RAINDROPS`             |Disables `RGB_MATRIX_RAINDROPS`             |
 163 |`#define DISABLE_RGB_MATRIX_CYCLE_ALL`             |Disables `RGB_MATRIX_CYCLE_ALL`             |
 164 |`#define DISABLE_RGB_MATRIX_CYCLE_LEFT_RIGHT`      |Disables `RGB_MATRIX_CYCLE_LEFT_RIGHT`      |
 165 |`#define DISABLE_RGB_MATRIX_CYCLE_UP_DOWN`         |Disables `RGB_MATRIX_CYCLE_UP_DOWN`         |
 166 |`#define DISABLE_RGB_MATRIX_RAINBOW_BEACON`        |Disables `RGB_MATRIX_RAINBOW_BEACON`        |
 167 |`#define DISABLE_RGB_MATRIX_RAINBOW_PINWHEELS`     |Disables `RGB_MATRIX_RAINBOW_PINWHEELS`     |
 168 |`#define DISABLE_RGB_MATRIX_RAINBOW_MOVING_CHEVRON`|Disables `RGB_MATRIX_RAINBOW_MOVING_CHEVRON`|
 169 |`#define DISABLE_RGB_MATRIX_JELLYBEAN_RAINDROPS`   |Disables `RGB_MATRIX_JELLYBEAN_RAINDROPS`   |
 170 |`#define DISABLE_RGB_MATRIX_DIGITAL_RAIN`          |Disables `RGB_MATRIX_DIGITAL_RAIN`          |
 171 |`#define DISABLE_RGB_MATRIX_SOLID_REACTIVE`        |Disables `RGB_MATRIX_SOLID_REACTIVE`        |
 172 |`#define DISABLE_RGB_MATRIX_SPLASH`                |Disables `RGB_MATRIX_SPLASH`                |
 173 |`#define DISABLE_RGB_MATRIX_MULTISPLASH`           |Disables `RGB_MATRIX_MULTISPLASH`           |
 174 |`#define DISABLE_RGB_MATRIX_SOLID_SPLASH`          |Disables `RGB_MATRIX_SOLID_SPLASH`          |
 175 |`#define DISABLE_RGB_MATRIX_SOLID_MULTISPLASH`     |Disables `RGB_MATRIX_SOLID_MULTISPLASH`     |
 176
 177
 178 ## Custom layer effects
 179
 180 Custom layer effects can be done by defining this in your `<keyboard>.c`:
 181
 182     void rgb_matrix_indicators_kb(void) {
 183         rgb_matrix_set_color(index, red, green, blue);
 184     }
 185
 186 A similar function works in the keymap as `rgb_matrix_indicators_user`.
 187
 188 ## Additional `config.h` Options
 189
 190         #define RGB_MATRIX_KEYPRESSES // reacts to keypresses (will slow down matrix scan by a lot)
 191         #define RGB_MATRIX_KEYRELEASES // reacts to keyreleases (not recommened)
 192         #define RGB_DISABLE_AFTER_TIMEOUT 0 // number of ticks to wait until disabling effects
 193         #define RGB_DISABLE_WHEN_USB_SUSPENDED false // turn off effects when suspended
 194     #define RGB_MATRIX_SKIP_FRAMES 1 // number of frames to skip when displaying animations (0 is full effect) if not defined defaults to 1
 195     #define RGB_MATRIX_MAXIMUM_BRIGHTNESS 200 // limits maximum brightness of LEDs to 200 out of 255. If not defined maximum brightness is set to 255
 196
 197 ## EEPROM storage
 198
 199 The EEPROM for it is currently shared with the RGBLIGHT system (it's generally assumed only one RGB would be used at a time), but could be configured to use its own 32bit address with:
 200
 201     #define EECONFIG_RGB_MATRIX (uint32_t *)16
 202
 203 Where `16` is an unused index from `eeconfig.h`.
 204
 205 ## Suspended state
 206
 207 To use the suspend feature, add this to your `<keyboard>.c`:
 208
 209         void suspend_power_down_kb(void)
 210         {
 211             rgb_matrix_set_suspend_state(true);
 212         }
 213
 214         void suspend_wakeup_init_kb(void)
 215         {
 216             rgb_matrix_set_suspend_state(false);
 217         }