keyboards/v60_type_r/v60_type_r.c

   1 /* Copyright 2017 benlyall, MechMerlin
   2  *
   3  * This program is free software: you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation, either version 2 of the License, or
   6  * (at your option) any later version.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  15  */
  16 #include "v60_type_r.h"
  17
  18 #include "quantum.h"
  19
  20 // if we've got an RGB underglow!
  21 #ifdef V60_POLESTAR
  22
  23 #include "rgblight.h"
  24
  25 #include <avr/pgmspace.h>
  26
  27 #include "action_layer.h"
  28
  29 #define SOFTPWM_LED_TIMER_TOP F_CPU/(256*64)
  30
  31 extern rgblight_config_t rgblight_config;
  32 static uint8_t softpwm_buff[3] = {0};
  33
  34 void matrix_init_kb(void) {
  35         rgb_init();
  36         matrix_init_user();
  37 }
  38
  39 bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
  40         uint8_t r = led[0].r, g = led[0].g, b = led[0].b;
  41         switch(keycode) {
  42                 case RGB_RI:
  43                         if (record->event.pressed) {
  44                                 r += RGB_STEP;
  45                                 if (r < led[0].r) {
  46                                         r = 255;
  47                                 }
  48                                 rgblight_setrgb(r, g, b);
  49                         }
  50
  51                         return false;
  52                 case RGB_RD:
  53                   if (record->event.pressed) {
  54                         r -= RGB_STEP;
  55                                 if (r > led[0].r) {
  56                                         r = 0;
  57                                 }
  58                                 rgblight_setrgb(r, g, b);
  59                   }
  60
  61                         return false;
  62                 case RGB_BI:
  63                         if (record->event.pressed) {
  64                                 b += RGB_STEP;
  65                                 if (b < led[0].b) {
  66                                         b = 255;
  67                                 }
  68                                 rgblight_setrgb(r, g, b);
  69                         }
  70
  71                         return false;
  72                 case RGB_BD:
  73                   if (record->event.pressed) {
  74                         b -= RGB_STEP;
  75                                 if (b > led[0].b) {
  76                                         b = 0;
  77                                 }
  78                                 rgblight_setrgb(r, g, b);
  79                   }
  80
  81                         return false;
  82                 case RGB_GI:
  83                         if (record->event.pressed) {
  84                                 g += RGB_STEP;
  85                                 if (g < led[0].g) {
  86                                         g = 255;
  87                                 }
  88                                 rgblight_setrgb(r, g, b);
  89                         }
  90
  91                         return false;
  92                 case RGB_GD:
  93                   if (record->event.pressed) {
  94                         g -= RGB_STEP;
  95                                 if (g > led[0].g) {
  96                                         g = 0;
  97                                 }
  98                                 rgblight_setrgb(r, g, b);
  99                         }
 100
 101                         return false;
 102         }
 103
 104         return process_record_user(keycode, record);
 105 }
 106
 107
 108 void rgb_timer_init(void) {
 109     /* Timer1 setup */
 110     /* CTC mode */
 111     TCCR1B |= (1<<WGM12);
 112     /* Clock selelct: clk/8 */
 113     TCCR1B |= (1<<CS10);
 114     /* Set TOP value */
 115     uint8_t sreg = SREG;
 116     cli();
 117     OCR1AH = (SOFTPWM_LED_TIMER_TOP >> 8) & 0xff;
 118     OCR1AL = SOFTPWM_LED_TIMER_TOP & 0xff;
 119     SREG = sreg;
 120
 121     // Enable the compare match interrupt on timer 1
 122     TIMSK1 |= (1<<OCIE1A);
 123 }
 124
 125 void rgb_init(void) {
 126     DDRF  |=  (1<<PF6 | 1<<PF5 | 1<<PF4);
 127     PORTF |=  (1<<PF6 | 1<<PF5 | 1<<PF4);
 128
 129     rgb_timer_init();
 130 }
 131
 132 void set_rgb_pin_on(uint8_t pin) {
 133         PORTF &= ~(1<<pin);
 134 }
 135
 136 void set_rgb_pin_off(uint8_t pin) {
 137         PORTF |= (1<<pin);
 138 }
 139
 140 void rgblight_set(void) {
 141           // xprintf("Setting RGB underglow\n");
 142     if (!rgblight_config.enable) {
 143           led[0].r = 0;
 144           led[0].g = 0;
 145           led[0].b = 0;
 146           set_rgb_pin_off(RGB_RED_PIN);
 147           set_rgb_pin_off(RGB_GREEN_PIN);
 148           set_rgb_pin_off(RGB_BLUE_PIN);
 149     }
 150
 151    //  //xprintf("Red: %u, Green: %u, Blue: %u\n", led[0].r, led[0].g, led[0].b);
 152 }
 153
 154 ISR(TIMER1_COMPA_vect)
 155 {
 156     static uint8_t pwm = 0;
 157     pwm++;
 158
 159     // turn the LEDS on
 160     if (pwm == 0) {
 161         if (softpwm_buff[0]) {
 162                 set_rgb_pin_on(RGB_RED_PIN);
 163                 softpwm_buff[0] = led[0].r;
 164         }
 165
 166         if (softpwm_buff[1]) {
 167                 set_rgb_pin_on(RGB_GREEN_PIN);
 168                 softpwm_buff[1] = led[0].g;
 169         }
 170
 171         if (softpwm_buff[2]) {
 172                 set_rgb_pin_on(RGB_BLUE_PIN);
 173                 softpwm_buff[2] = led[0].b;
 174         }
 175     }
 176
 177     // turn em off
 178         if (pwm == softpwm_buff[0]) {
 179                 set_rgb_pin_off(RGB_RED_PIN);
 180                 softpwm_buff[0] = led[0].r;
 181
 182         }
 183
 184         if (pwm == softpwm_buff[1]) {
 185                 set_rgb_pin_off(RGB_GREEN_PIN);
 186         softpwm_buff[1] = led[0].g;
 187         }
 188
 189         if (pwm == softpwm_buff[2]) {
 190                 set_rgb_pin_off(RGB_BLUE_PIN);
 191         softpwm_buff[2] = led[0].b;
 192         }
 193 }
 194 #endif // V60_POLESTAR