|
|
/* -*- mode: c++ -*-
|
|
|
* Kaleidoscope-Heatmap -- Heatmap LED effect for Kaleidoscope.
|
|
|
* Copyright (C) 2016, 2017 Keyboard.io, Inc.
|
|
|
*
|
|
|
* 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, version 3.
|
|
|
*
|
|
|
* 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 <Kaleidoscope.h>
|
|
|
#include <Kaleidoscope-Heatmap.h>
|
|
|
|
|
|
namespace kaleidoscope {
|
|
|
namespace plugin {
|
|
|
|
|
|
// store the number of times each key has been strock
|
|
|
uint16_t Heatmap::heatmap_[ROWS][COLS];
|
|
|
// max of heatmap_ (we divide by it so we start at 1)
|
|
|
uint16_t Heatmap::highest_ = 1;
|
|
|
// next heatmap computation time
|
|
|
uint32_t Heatmap::next_heatmap_comp_time_ = 0;
|
|
|
// in the cRGB struct the order is blue, green, red (It should be called cBGR…)
|
|
|
// default heat_colors black green yellow red
|
|
|
static const cRGB heat_colors_default_[] PROGMEM = {{0, 0, 0}, {25, 255, 25}, {25, 255, 255}, {25, 25, 255}};
|
|
|
|
|
|
// colors from cold to hot
|
|
|
const cRGB *Heatmap::heat_colors = heat_colors_default_;
|
|
|
uint8_t Heatmap::heat_colors_length = 4;
|
|
|
// number of millisecond to wait between each heatmap computation
|
|
|
uint16_t Heatmap::update_delay = 1000;
|
|
|
|
|
|
cRGB Heatmap::computeColor(float v) {
|
|
|
// compute the color corresponding to a value between 0 and 1
|
|
|
|
|
|
/*
|
|
|
* for exemple, if:
|
|
|
* v=0.8
|
|
|
* heat_colors_lenth=4 (hcl)
|
|
|
* the red components of heat_colors are: 0, 25, 25, 255 (rhc)
|
|
|
* the red component returned by computeColor will be: 117
|
|
|
*
|
|
|
* 255 | /
|
|
|
* | /
|
|
|
* | /
|
|
|
* 117 | - - - - - - -/
|
|
|
* | /
|
|
|
* 25 | ______/ |
|
|
|
* | __/
|
|
|
* | _/ |
|
|
|
* |/_________________
|
|
|
* 0 1 2 ↑ 3
|
|
|
* ↑ 2.4 ↑
|
|
|
* idx1 | idx2
|
|
|
* <—–>
|
|
|
* fb
|
|
|
*
|
|
|
* in this exemple, I call red heat_colors: rhc
|
|
|
* idx1 = floor(v×(hcl-1)) = floor(0.8×3) = floor(2.4) = 2
|
|
|
* idx2 = idx1 + 1 = 3
|
|
|
* fb = v×(hcl-1)-idx1 = 0.8×3 - 2 = 0.4
|
|
|
* red = (rhc[idx2]-rhc[idx1])×fb + rhc[idx1] = (255-25)×(2.4-2) + 25 = 117
|
|
|
*/
|
|
|
|
|
|
float fb = 0;
|
|
|
uint8_t idx1, idx2;
|
|
|
|
|
|
if (v <= 0) {
|
|
|
// if v = 0, don't bother computing fb and use heat_colors[0]
|
|
|
idx1 = idx2 = 0;
|
|
|
} else if (v >= 1) {
|
|
|
// if v = 1,
|
|
|
// don't bother computing fb and use heat_colors[heat_colors_length-1]
|
|
|
idx1 = idx2 = heat_colors_length - 1;
|
|
|
} else {
|
|
|
float val = v * (heat_colors_length - 1);
|
|
|
// static_cast from float to int just drop the decimal part of the number
|
|
|
// static_cast<int>(5.9) → 5
|
|
|
idx1 = static_cast<int>(val);
|
|
|
idx2 = idx1 + 1;
|
|
|
fb = val - static_cast<float>(idx1);
|
|
|
}
|
|
|
|
|
|
uint8_t r = static_cast<uint8_t>((pgm_read_byte(&(heat_colors[idx2].r)) - pgm_read_byte(&(heat_colors[idx1].r))) * fb + pgm_read_byte(&(heat_colors[idx1].r)));
|
|
|
uint8_t g = static_cast<uint8_t>((pgm_read_byte(&(heat_colors[idx2].g)) - pgm_read_byte(&(heat_colors[idx1].g))) * fb + pgm_read_byte(&(heat_colors[idx1].g)));
|
|
|
uint8_t b = static_cast<uint8_t>((pgm_read_byte(&(heat_colors[idx2].b)) - pgm_read_byte(&(heat_colors[idx1].b))) * fb + pgm_read_byte(&(heat_colors[idx1].b)));
|
|
|
|
|
|
return {b, g, r};
|
|
|
}
|
|
|
|
|
|
void Heatmap::shiftStats(void) {
|
|
|
// this method is called when:
|
|
|
// 1. a value in heatmap_ reach INT8_MAX
|
|
|
// 2. highest_ reach heat_colors_length*512 (see Heatmap::loopHook)
|
|
|
|
|
|
// we divide every heatmap element by 2
|
|
|
for (uint8_t r = 0; r < ROWS; r++) {
|
|
|
for (uint8_t c = 0; c < COLS; c++) {
|
|
|
heatmap_[r][c] = heatmap_[r][c] >> 1;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// and also divide highest_ accordingly
|
|
|
highest_ = highest_ >> 1;
|
|
|
}
|
|
|
|
|
|
void Heatmap::resetMap(void) {
|
|
|
// this method can be used as a way to work around an existing bug with a single key
|
|
|
// getting special attention or if the user just wants a button to reset the map
|
|
|
for (uint8_t r = 0; r < ROWS; r++) {
|
|
|
for (uint8_t c = 0; c < COLS; c++) {
|
|
|
heatmap_[r][c] = 0;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
highest_ = 1;
|
|
|
}
|
|
|
|
|
|
EventHandlerResult Heatmap::onKeyswitchEvent(Key &mapped_key, byte row, byte col, uint8_t key_state) {
|
|
|
if (!Kaleidoscope.has_leds)
|
|
|
return EventHandlerResult::OK;
|
|
|
|
|
|
// this methode is called frequently by Kaleidoscope
|
|
|
// even if the module isn't activated
|
|
|
|
|
|
// if it is a synthetic key, skip it
|
|
|
if (key_state & INJECTED)
|
|
|
return EventHandlerResult::OK;
|
|
|
|
|
|
// if the key is not toggled on, skip it
|
|
|
if (!keyToggledOn(key_state))
|
|
|
return EventHandlerResult::OK;
|
|
|
|
|
|
// increment the heatmap_ value related to the key
|
|
|
heatmap_[row][col]++;
|
|
|
|
|
|
// check highest_
|
|
|
if (highest_ < heatmap_[row][col]) {
|
|
|
highest_ = heatmap_[row][col];
|
|
|
|
|
|
// if highest_ (and so heatmap_ value related to the key)
|
|
|
// is close to overflow: call shiftStats
|
|
|
// NOTE: this is barely impossible since shiftStats should be
|
|
|
// called much sooner by Heatmap::loopHook
|
|
|
if (highest_ == INT16_MAX)
|
|
|
shiftStats();
|
|
|
}
|
|
|
|
|
|
return EventHandlerResult::OK;
|
|
|
}
|
|
|
|
|
|
EventHandlerResult Heatmap::beforeEachCycle() {
|
|
|
if (!Kaleidoscope.has_leds)
|
|
|
return EventHandlerResult::OK;
|
|
|
|
|
|
// this methode is called frequently by Kaleidoscope
|
|
|
// even if the module isn't activated
|
|
|
|
|
|
// call shiftStats (divide every heatmap value by 2)
|
|
|
// if highest_ reach heat_colors_length*512.
|
|
|
// So after the shift, highest_ will be heat_colors_length*256. We
|
|
|
// didn't lose any precision in our heatmap since between each color we have a
|
|
|
// maximum precision of 256 ; said differently, there is 256 state (at max)
|
|
|
// between heat_colors[x] and heat_colors[x+1].
|
|
|
if (highest_ > (static_cast<uint16_t>(heat_colors_length) << 9))
|
|
|
shiftStats();
|
|
|
|
|
|
return EventHandlerResult::OK;
|
|
|
}
|
|
|
|
|
|
void Heatmap::update(void) {
|
|
|
if (!Kaleidoscope.has_leds)
|
|
|
return;
|
|
|
|
|
|
// this methode is called frequently by the LEDControl::loopHook
|
|
|
|
|
|
// do nothing if we didn't reach next_heatmap_comp_time_ yet
|
|
|
if (next_heatmap_comp_time_ && (millis() < next_heatmap_comp_time_))
|
|
|
return;
|
|
|
// do the heatmap computing
|
|
|
// (we reach next_heatmap_comp_time_ or next_heatmap_comp_time_ was never scheduled)
|
|
|
|
|
|
// schedule the next heatmap computing
|
|
|
next_heatmap_comp_time_ = millis() + update_delay;
|
|
|
|
|
|
// for each key
|
|
|
for (uint8_t r = 0; r < ROWS; r++) {
|
|
|
for (uint8_t c = 0; c < COLS; c++) {
|
|
|
// how much the key was pressed compared to the others (between 0 and 1)
|
|
|
// (total_keys_ can't be equal to 0)
|
|
|
float v = static_cast<float>(heatmap_[r][c]) / highest_;
|
|
|
// we could have used an interger instead of a float, but then we would
|
|
|
// have had to change some multiplication in division.
|
|
|
// / on uint is slower than * on float, so I stay with the float
|
|
|
// https://forum.arduino.cc/index.php?topic=92684.msg2733723#msg2733723
|
|
|
|
|
|
// set the LED color accordingly
|
|
|
::LEDControl.setCrgbAt(r, c, computeColor(v));
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
}
|
|
|
}
|
|
|
|
|
|
kaleidoscope::plugin::Heatmap HeatmapEffect;
|
