tmk_core/protocol/arm_atsam/led_matrix.c

   1 /*
   2 Copyright 2018 Massdrop Inc.
   3
   4 This program is free software: you can redistribute it and/or modify
   5 it under the terms of the GNU General Public License as published by
   6 the Free Software Foundation, either version 2 of the License, or
   7 (at your option) any later version.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 GNU General Public License for more details.
  13
  14 You should have received a copy of the GNU General Public License
  15 along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16 */
  17
  18 #include "arm_atsam_protocol.h"
  19 #include "tmk_core/common/led.h"
  20 #include <string.h>
  21
  22 void SERCOM1_0_Handler( void )
  23 {
  24     if (SERCOM1->I2CM.INTFLAG.bit.ERROR)
  25     {
  26         SERCOM1->I2CM.INTFLAG.reg = SERCOM_I2CM_INTENCLR_ERROR;
  27     }
  28 }
  29
  30 void DMAC_0_Handler( void )
  31 {
  32     if (DMAC->Channel[0].CHINTFLAG.bit.TCMPL)
  33     {
  34         DMAC->Channel[0].CHINTFLAG.reg = DMAC_CHINTENCLR_TCMPL;
  35
  36         i2c1_stop();
  37
  38         i2c_led_q_running = 0;
  39
  40         i2c_led_q_run();
  41
  42         return;
  43     }
  44
  45     if (DMAC->Channel[0].CHINTFLAG.bit.TERR)
  46     {
  47         DMAC->Channel[0].CHINTFLAG.reg = DMAC_CHINTENCLR_TERR;
  48     }
  49 }
  50
  51 issi3733_driver_t issidrv[ISSI3733_DRIVER_COUNT];
  52
  53 issi3733_led_t led_map[ISSI3733_LED_COUNT+1] = ISSI3733_LED_MAP;
  54 issi3733_led_t *lede = led_map + ISSI3733_LED_COUNT; //End pointer of mapping
  55
  56 uint8_t gcr_desired;
  57 uint8_t gcr_breathe;
  58 uint8_t gcr_use;
  59 uint8_t gcr_actual;
  60 uint8_t gcr_actual_last;
  61
  62 #define ACT_GCR_NONE    0
  63 #define ACT_GCR_INC     1
  64 #define ACT_GCR_DEC     2
  65
  66 #define LED_GCR_STEP_AUTO 2
  67
  68 static uint8_t gcr_min_counter;
  69 static uint8_t v_5v_cat_hit;
  70
  71 //WARNING: Automatic GCR is in place to prevent USB shutdown and LED driver overloading
  72 void gcr_compute(void)
  73 {
  74     uint8_t action = ACT_GCR_NONE;
  75
  76     if (led_animation_breathing)
  77         gcr_use = gcr_breathe;
  78     else
  79         gcr_use = gcr_desired;
  80
  81     //If the 5v takes a catastrophic hit, disable the LED drivers briefly, assert auto gcr mode, min gcr and let the auto take over
  82     if (v_5v < V5_CAT)
  83     {
  84         I2C3733_Control_Set(0);
  85         //CDC_print("USB: WARNING: 5V catastrophic level reached! Disabling LED drivers!\r\n"); //Blocking print is bad here!
  86         v_5v_cat_hit = 20; //~100ms recover
  87         gcr_actual = 0; //Minimize GCR
  88         usb_gcr_auto = 1; //Force auto mode enabled
  89         return;
  90     }
  91     else if (v_5v_cat_hit > 1)
  92     {
  93         v_5v_cat_hit--;
  94         return;
  95     }
  96     else if (v_5v_cat_hit == 1)
  97     {
  98         I2C3733_Control_Set(1);
  99         CDC_print("USB: WARNING: Re-enabling LED drivers\r\n");
 100         v_5v_cat_hit = 0;
 101         return;
 102     }
 103
 104     if (usb_gcr_auto)
 105     {
 106         if (v_5v_avg < V5_LOW) action = ACT_GCR_DEC;
 107         else if (v_5v_avg > V5_HIGH && gcr_actual < gcr_use) action = ACT_GCR_INC;
 108         else if (gcr_actual > gcr_use) action = ACT_GCR_DEC;
 109     }
 110     else
 111     {
 112         if (gcr_actual < gcr_use) action = ACT_GCR_INC;
 113         else if (gcr_actual > gcr_use) action = ACT_GCR_DEC;
 114     }
 115
 116     if (action == ACT_GCR_NONE)
 117     {
 118         gcr_min_counter = 0;
 119     }
 120     else if (action == ACT_GCR_INC)
 121     {
 122         if (LED_GCR_STEP_AUTO > LED_GCR_MAX - gcr_actual) gcr_actual = LED_GCR_MAX; //Obey max and prevent wrapping
 123         else gcr_actual += LED_GCR_STEP_AUTO;
 124         gcr_min_counter = 0;
 125     }
 126     else if (action == ACT_GCR_DEC)
 127     {
 128         if (LED_GCR_STEP_AUTO > gcr_actual) //Prevent wrapping
 129         {
 130             gcr_actual = 0;
 131             //At this point, power can no longer be cut from the LED drivers, so focus on cutting out extra port if active
 132             if (usb_extra_state != USB_EXTRA_STATE_DISABLED_UNTIL_REPLUG) //If not in a wait for replug state
 133             {
 134                 if (usb_extra_state == USB_EXTRA_STATE_ENABLED) //If extra usb is enabled
 135                 {
 136                     gcr_min_counter++;
 137                     if (gcr_min_counter > 200) //5ms per check = 1s delay
 138                     {
 139                         USB_ExtraSetState(USB_EXTRA_STATE_DISABLED_UNTIL_REPLUG);
 140                         usb_extra_manual = 0; //Force disable manual mode of extra port
 141                         if (usb_extra_manual) CDC_print("USB: Disabling extra port until replug and manual mode toggle!\r\n");
 142                         else CDC_print("USB: Disabling extra port until replug!\r\n");
 143                     }
 144                 }
 145             }
 146         }
 147         else
 148         {
 149             //Power successfully cut back from LED drivers
 150             gcr_actual -= LED_GCR_STEP_AUTO;
 151             gcr_min_counter = 0;
 152
 153             //If breathe mode is active, the top end can fluctuate if the host can not supply enough current
 154             //So set the breathe GCR to where it becomes stable
 155             if (led_animation_breathing == 1)
 156             {
 157                 gcr_breathe = gcr_actual;
 158                 //PS: At this point, setting breathing to exhale makes a noticebly shorter cycle
 159                 //    and the same would happen maybe one or two more times. Therefore I'm favoring
 160                 //    powering through one full breathe and letting gcr settle completely
 161             }
 162         }
 163     }
 164 }
 165
 166 led_disp_t disp;
 167
 168 void issi3733_prepare_arrays(void)
 169 {
 170     memset(issidrv,0,sizeof(issi3733_driver_t) * ISSI3733_DRIVER_COUNT);
 171
 172     int i;
 173     uint8_t addrs[ISSI3733_DRIVER_COUNT] = ISSI3773_DRIVER_ADDRESSES;
 174
 175     for (i=0;i<ISSI3733_DRIVER_COUNT;i++)
 176     {
 177         issidrv[i].addr = addrs[i];
 178     }
 179
 180     issi3733_led_t *cur = led_map;
 181
 182     while (cur < lede)
 183     {
 184         //BYTE: 1 + (SW-1)*16 + (CS-1)
 185         cur->rgb.g = issidrv[cur->adr.drv-1].pwm + 1 + ((cur->adr.swg-1)*16 + (cur->adr.cs-1));
 186         cur->rgb.r = issidrv[cur->adr.drv-1].pwm + 1 + ((cur->adr.swr-1)*16 + (cur->adr.cs-1));
 187         cur->rgb.b = issidrv[cur->adr.drv-1].pwm + 1 + ((cur->adr.swb-1)*16 + (cur->adr.cs-1));
 188
 189         //BYTE: 1 + (SW-1)*2 + (CS-1)/8
 190         //BIT: (CS-1)%8
 191         *(issidrv[cur->adr.drv-1].onoff + 1 + (cur->adr.swg-1)*2+(cur->adr.cs-1)/8) |= (1<<((cur->adr.cs-1)%8));
 192         *(issidrv[cur->adr.drv-1].onoff + 1 + (cur->adr.swr-1)*2+(cur->adr.cs-1)/8) |= (1<<((cur->adr.cs-1)%8));
 193         *(issidrv[cur->adr.drv-1].onoff + 1 + (cur->adr.swb-1)*2+(cur->adr.cs-1)/8) |= (1<<((cur->adr.cs-1)%8));
 194
 195         cur++;
 196     }
 197 }
 198
 199 void disp_calc_extents(void)
 200 {
 201     issi3733_led_t *cur = led_map;
 202
 203     disp.left = 1e10;
 204     disp.right = -1e10;
 205     disp.top = -1e10;
 206     disp.bottom = 1e10;
 207
 208     while (cur < lede)
 209     {
 210         if (cur->x < disp.left) disp.left = cur->x;
 211         if (cur->x > disp.right) disp.right = cur->x;
 212         if (cur->y < disp.bottom) disp.bottom = cur->y;
 213         if (cur->y > disp.top) disp.top = cur->y;
 214
 215         cur++;
 216     }
 217
 218     disp.width = disp.right - disp.left;
 219     disp.height = disp.top - disp.bottom;
 220 }
 221
 222 void disp_pixel_setup(void)
 223 {
 224     issi3733_led_t *cur = led_map;
 225
 226     while (cur < lede)
 227     {
 228         cur->px = (cur->x - disp.left) / disp.width * 100;
 229         cur->py = (cur->y - disp.top) / disp.height * 100;
 230         *cur->rgb.r = 0;
 231         *cur->rgb.g = 0;
 232         *cur->rgb.b = 0;
 233
 234         cur++;
 235     }
 236 }
 237
 238 void led_matrix_prepare(void)
 239 {
 240     disp_calc_extents();
 241     disp_pixel_setup();
 242 }
 243
 244 uint8_t led_enabled;
 245 float led_animation_speed;
 246 uint8_t led_animation_direction;
 247 uint8_t led_animation_breathing;
 248 uint8_t led_animation_breathe_cur;
 249 uint8_t breathe_step;
 250 uint8_t breathe_dir;
 251 uint64_t led_next_run;
 252
 253 uint8_t led_animation_id;
 254 uint8_t led_lighting_mode;
 255
 256 issi3733_led_t *led_cur;
 257 uint8_t led_per_run = 15;
 258 float breathe_mult;
 259
 260 __attribute__ ((weak))
 261 void led_matrix_run(void)
 262 {
 263     float ro;
 264     float go;
 265     float bo;
 266     float px;
 267     uint8_t led_this_run = 0;
 268     led_setup_t *f = (led_setup_t*)led_setups[led_animation_id];
 269
 270     if (led_cur == 0) //Denotes start of new processing cycle in the case of chunked processing
 271     {
 272         led_cur = led_map;
 273
 274         disp.frame += 1;
 275
 276         breathe_mult = 1;
 277
 278         if (led_animation_breathing)
 279         {
 280             led_animation_breathe_cur += breathe_step * breathe_dir;
 281
 282             if (led_animation_breathe_cur >= BREATHE_MAX_STEP)
 283                 breathe_dir = -1;
 284             else if (led_animation_breathe_cur <= BREATHE_MIN_STEP)
 285                 breathe_dir = 1;
 286
 287             //Brightness curve created for 256 steps, 0 - ~98%
 288             breathe_mult = 0.000015 * led_animation_breathe_cur * led_animation_breathe_cur;
 289             if (breathe_mult > 1) breathe_mult = 1;
 290             else if (breathe_mult < 0) breathe_mult = 0;
 291         }
 292     }
 293
 294     uint8_t fcur = 0;
 295     uint8_t fmax = 0;
 296
 297     //Frames setup
 298     while (f[fcur].end != 1)
 299     {
 300         fcur++; //Count frames
 301     }
 302
 303     fmax = fcur; //Store total frames count
 304
 305     while (led_cur < lede && led_this_run < led_per_run)
 306     {
 307         ro = 0;
 308         go = 0;
 309         bo = 0;
 310
 311         if (led_lighting_mode == LED_MODE_KEYS_ONLY && led_cur->scan == 255)
 312         {
 313             //Do not act on this LED
 314         }
 315         else if (led_lighting_mode == LED_MODE_NON_KEYS_ONLY && led_cur->scan != 255)
 316         {
 317             //Do not act on this LED
 318         }
 319         else if (led_lighting_mode == LED_MODE_INDICATORS_ONLY)
 320         {
 321             //Do not act on this LED (Only show indicators)
 322         }
 323         else
 324         {
 325             //Act on LED
 326             for (fcur = 0; fcur < fmax; fcur++)
 327             {
 328                 px = led_cur->px;
 329                 float pxmod;
 330                 pxmod = (float)(disp.frame % (uint32_t)(1000.0f / led_animation_speed)) / 10.0f * led_animation_speed;
 331
 332                 //Add in any moving effects
 333                 if ((!led_animation_direction && f[fcur].ef & EF_SCR_R) || (led_animation_direction && (f[fcur].ef & EF_SCR_L)))
 334                 {
 335                     pxmod *= 100.0f;
 336                     pxmod = (uint32_t)pxmod % 10000;
 337                     pxmod /= 100.0f;
 338
 339                     px -= pxmod;
 340
 341                     if (px > 100) px -= 100;
 342                     else if (px < 0) px += 100;
 343                 }
 344                 else if ((!led_animation_direction && f[fcur].ef & EF_SCR_L) || (led_animation_direction && (f[fcur].ef & EF_SCR_R)))
 345                 {
 346                     pxmod *= 100.0f;
 347                     pxmod = (uint32_t)pxmod % 10000;
 348                     pxmod /= 100.0f;
 349                     px += pxmod;
 350
 351                     if (px > 100) px -= 100;
 352                     else if (px < 0) px += 100;
 353                 }
 354
 355                 //Check if LED's px is in current frame
 356                 if (px < f[fcur].hs) continue;
 357                 if (px > f[fcur].he) continue;
 358                 //note: < 0 or > 100 continue
 359
 360                 //Calculate the px within the start-stop percentage for color blending
 361                 px = (px - f[fcur].hs) / (f[fcur].he - f[fcur].hs);
 362
 363                 //Add in any color effects
 364                 if (f[fcur].ef & EF_OVER)
 365                 {
 366                     ro = (px * (f[fcur].re - f[fcur].rs)) + f[fcur].rs;// + 0.5;
 367                     go = (px * (f[fcur].ge - f[fcur].gs)) + f[fcur].gs;// + 0.5;
 368                     bo = (px * (f[fcur].be - f[fcur].bs)) + f[fcur].bs;// + 0.5;
 369                 }
 370                 else if (f[fcur].ef & EF_SUBTRACT)
 371                 {
 372                     ro -= (px * (f[fcur].re - f[fcur].rs)) + f[fcur].rs;// + 0.5;
 373                     go -= (px * (f[fcur].ge - f[fcur].gs)) + f[fcur].gs;// + 0.5;
 374                     bo -= (px * (f[fcur].be - f[fcur].bs)) + f[fcur].bs;// + 0.5;
 375                 }
 376                 else
 377                 {
 378                     ro += (px * (f[fcur].re - f[fcur].rs)) + f[fcur].rs;// + 0.5;
 379                     go += (px * (f[fcur].ge - f[fcur].gs)) + f[fcur].gs;// + 0.5;
 380                     bo += (px * (f[fcur].be - f[fcur].bs)) + f[fcur].bs;// + 0.5;
 381                 }
 382             }
 383         }
 384
 385         //Clamp values 0-255
 386         if (ro > 255) ro = 255; else if (ro < 0) ro = 0;
 387         if (go > 255) go = 255; else if (go < 0) go = 0;
 388         if (bo > 255) bo = 255; else if (bo < 0) bo = 0;
 389
 390         if (led_animation_breathing)
 391         {
 392             ro *= breathe_mult;
 393             go *= breathe_mult;
 394             bo *= breathe_mult;
 395         }
 396
 397         *led_cur->rgb.r = (uint8_t)ro;
 398         *led_cur->rgb.g = (uint8_t)go;
 399         *led_cur->rgb.b = (uint8_t)bo;
 400
 401 #ifdef USB_LED_INDICATOR_ENABLE
 402         if (keyboard_leds())
 403         {
 404             uint8_t kbled = keyboard_leds();
 405             if (
 406                 #if USB_LED_NUM_LOCK_SCANCODE != 255
 407                 (led_cur->scan == USB_LED_NUM_LOCK_SCANCODE && kbled & (1<<USB_LED_NUM_LOCK)) ||
 408                 #endif //NUM LOCK
 409                 #if USB_LED_CAPS_LOCK_SCANCODE != 255
 410                 (led_cur->scan == USB_LED_CAPS_LOCK_SCANCODE && kbled & (1<<USB_LED_CAPS_LOCK)) ||
 411                 #endif //CAPS LOCK
 412                 #if USB_LED_SCROLL_LOCK_SCANCODE != 255
 413                 (led_cur->scan == USB_LED_SCROLL_LOCK_SCANCODE && kbled & (1<<USB_LED_SCROLL_LOCK)) ||
 414                 #endif //SCROLL LOCK
 415                 #if USB_LED_COMPOSE_SCANCODE != 255
 416                 (led_cur->scan == USB_LED_COMPOSE_SCANCODE && kbled & (1<<USB_LED_COMPOSE)) ||
 417                 #endif //COMPOSE
 418                 #if USB_LED_KANA_SCANCODE != 255
 419                 (led_cur->scan == USB_LED_KANA_SCANCODE && kbled & (1<<USB_LED_KANA)) ||
 420                 #endif //KANA
 421                 (0))
 422             {
 423                 if (*led_cur->rgb.r > 127) *led_cur->rgb.r = 0;
 424                 else *led_cur->rgb.r = 255;
 425                 if (*led_cur->rgb.g > 127) *led_cur->rgb.g = 0;
 426                 else *led_cur->rgb.g = 255;
 427                 if (*led_cur->rgb.b > 127) *led_cur->rgb.b = 0;
 428                 else *led_cur->rgb.b = 255;
 429             }
 430         }
 431 #endif //USB_LED_INDICATOR_ENABLE
 432
 433         led_cur++;
 434         led_this_run++;
 435     }
 436 }
 437
 438 uint8_t led_matrix_init(void)
 439 {
 440     DBGC(DC_LED_MATRIX_INIT_BEGIN);
 441
 442     issi3733_prepare_arrays();
 443
 444     led_matrix_prepare();
 445
 446     disp.frame = 0;
 447     led_next_run = 0;
 448
 449     led_enabled = 1;
 450     led_animation_id = 0;
 451     led_lighting_mode = LED_MODE_NORMAL;
 452     led_animation_speed = 4.0f;
 453     led_animation_direction = 0;
 454     led_animation_breathing = 0;
 455     led_animation_breathe_cur = BREATHE_MIN_STEP;
 456     breathe_step = 1;
 457     breathe_dir = 1;
 458
 459     gcr_min_counter = 0;
 460     v_5v_cat_hit = 0;
 461
 462     //Run led matrix code once for initial LED coloring
 463     led_cur = 0;
 464     rgb_matrix_init_user();
 465     led_matrix_run();
 466
 467     DBGC(DC_LED_MATRIX_INIT_COMPLETE);
 468
 469     return 0;
 470 }
 471
 472 __attribute__ ((weak))
 473 void rgb_matrix_init_user(void) {
 474
 475 }
 476
 477 #define LED_UPDATE_RATE 10  //ms
 478
 479 //led data processing can take time, so process data in chunks to free up the processor
 480 //this is done through led_cur and lede
 481 void led_matrix_task(void)
 482 {
 483     if (led_enabled)
 484     {
 485         //If an update may run and frame processing has completed
 486         if (CLK_get_ms() >= led_next_run && led_cur == lede)
 487         {
 488             uint8_t drvid;
 489
 490             led_next_run = CLK_get_ms() + LED_UPDATE_RATE;  //Set next frame update time
 491
 492             //NOTE: GCR does not need to be timed with LED processing, but there is really no harm
 493             if (gcr_actual != gcr_actual_last)
 494             {
 495                 for (drvid=0;drvid<ISSI3733_DRIVER_COUNT;drvid++)
 496                     I2C_LED_Q_GCR(drvid); //Queue data
 497                 gcr_actual_last = gcr_actual;
 498             }
 499
 500             for (drvid=0;drvid<ISSI3733_DRIVER_COUNT;drvid++)
 501                 I2C_LED_Q_PWM(drvid); //Queue data
 502
 503             i2c_led_q_run();
 504
 505             led_cur = 0; //Signal next frame calculations may begin
 506         }
 507     }
 508
 509     //Process more data if not finished
 510     if (led_cur != lede)
 511     {
 512         //m15_off; //debug profiling
 513         led_matrix_run();
 514         //m15_on; //debug profiling
 515     }
 516 }
 517