520 lines
14 KiB
C
520 lines
14 KiB
C
|
/*
|
||
|
|
* led_rgbprog.c
|
||
|
|
*
|
||
|
|
* Created on: Jul 27, 2024
|
||
|
|
* Author: true
|
||
|
|
*/
|
||
|
|
#include <stdint.h>
|
||
|
|
|
||
|
|
#include "config.h"
|
||
|
|
#include "hsv2rgb.h"
|
||
|
|
#include "led.h"
|
||
|
|
#include "rand.h"
|
||
|
|
|
||
|
|
|
||
|
|
// led programs
|
||
|
|
void led_rgb_0_rainbow(uint8_t preview, uint8_t tick);
|
||
|
|
void led_rgb_1_lite_then_fade(uint8_t preview, uint8_t tick);
|
||
|
|
void led_rgb_2_twinkle(uint8_t preview, uint8_t tick);
|
||
|
|
void led_rgb_3_alternate(uint8_t preview, uint8_t tick);
|
||
|
|
void led_rgb_4_typing(uint8_t preview, uint8_t tick);
|
||
|
|
|
||
|
|
void ((*led_rgbprog[5])(uint8_t, uint8_t)) = {
|
||
|
|
led_rgb_0_rainbow,
|
||
|
|
led_rgb_1_lite_then_fade,
|
||
|
|
led_rgb_2_twinkle,
|
||
|
|
led_rgb_3_alternate,
|
||
|
|
led_rgb_4_typing
|
||
|
|
};
|
||
|
|
|
||
|
|
static uint8_t prog_rgb[3];
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
* always have to have unicorn piss
|
||
|
|
*
|
||
|
|
* button: angle (45 degree shifts for each press)
|
||
|
|
* knob: spacing
|
||
|
|
*/
|
||
|
|
static uint16_t rainbow_hue = 0;
|
||
|
|
|
||
|
|
// probably some way to compute this but I can't think of it right now
|
||
|
|
// might take more codespace than this 40-byte LUT anyway
|
||
|
|
// encoding: LED1-LED2 LED3-LED4 LED5-MAX
|
||
|
|
// LED6-LED7 LED8-LED9
|
||
|
|
static const uint8_t rainbow_angles[8][5] = {
|
||
|
|
{0x12, 0x34, 0x55,
|
||
|
|
0x01, 0x23}, // bottom left to top right
|
||
|
|
{0x01, 0x23, 0x44,
|
||
|
|
0x01, 0x23}, // left to right
|
||
|
|
{0x01, 0x23, 0x44,
|
||
|
|
0x12, 0x34}, // top left to bottom right
|
||
|
|
{0x00, 0x00, 0x02,
|
||
|
|
0x22, 0x22}, // top to bottom
|
||
|
|
{0x43, 0x21, 0x04,
|
||
|
|
0x32, 0x10}, // top right to bottom left
|
||
|
|
{0x43, 0x21, 0x04,
|
||
|
|
0x43, 0x21}, // right to left
|
||
|
|
{0x43, 0x21, 0x04,
|
||
|
|
0x32, 0x10}, // bottom right to top left
|
||
|
|
{0x22, 0x22, 0x22,
|
||
|
|
0x00, 0x00} // bottom to top
|
||
|
|
};
|
||
|
|
|
||
|
|
static void rainbow_letter_next()
|
||
|
|
{
|
||
|
|
uint16_t h;
|
||
|
|
|
||
|
|
// add to our hue
|
||
|
|
h = userconf.ledprog_setting[0][1];
|
||
|
|
h <<= 2;
|
||
|
|
|
||
|
|
rainbow_hue += h;
|
||
|
|
rainbow_hue++;
|
||
|
|
rainbow_hue %= 256*6;
|
||
|
|
|
||
|
|
// make a color out of it
|
||
|
|
hsv2rgb_8b(rainbow_hue, 255, 255, &prog_rgb[0], &prog_rgb[1], &prog_rgb[2]);
|
||
|
|
}
|
||
|
|
|
||
|
|
void led_rgb_0_rainbow(uint8_t preview, uint8_t tick)
|
||
|
|
{
|
||
|
|
uint8_t i, j; // iterator
|
||
|
|
uint8_t n; // led index, remapped
|
||
|
|
uint8_t idx; // led index being updated, 0-5
|
||
|
|
uint8_t max; // max number of iterations for this angle
|
||
|
|
uint8_t angle; // fill direction from LUT
|
||
|
|
|
||
|
|
// run at half framerate
|
||
|
|
if (tick & 1) {
|
||
|
|
// no matter what, this puke is getting updated
|
||
|
|
led_is_updated();
|
||
|
|
|
||
|
|
// setup
|
||
|
|
angle = userconf.ledprog_setting[0][0];
|
||
|
|
angle &= 0x7;
|
||
|
|
max = rainbow_angles[angle][2] & 0x7;
|
||
|
|
|
||
|
|
// process outputs
|
||
|
|
for (i = 0; i <= max; i++) {
|
||
|
|
// get the next puke
|
||
|
|
rainbow_letter_next();
|
||
|
|
|
||
|
|
// apply to next set of LEDs
|
||
|
|
n = 0;
|
||
|
|
for (j = 0; j < 9; j++) {
|
||
|
|
n++;
|
||
|
|
if (j == 5) n++; // nybble index
|
||
|
|
|
||
|
|
idx = rainbow_angles[angle][n >> 1]; // get mask byte
|
||
|
|
if ((n & 1) == 0) idx >>= 4; // shift even values over
|
||
|
|
idx &= 0x7; // mask lowest 3 bits
|
||
|
|
|
||
|
|
if (idx == i) { // is this LED part of this pattern?
|
||
|
|
if (preview) { // are we in preview mode?
|
||
|
|
if (j != 0) { // is the first letter not the one selected?
|
||
|
|
if ((preview & 0x7f) == 0) {// is this preview selected?
|
||
|
|
if (j < 5) continue; // pass over any outputs that are not "TECH" letters
|
||
|
|
}
|
||
|
|
} else return; // preview is not selected, so we're done here
|
||
|
|
}
|
||
|
|
rgb[j][0] = prog_rgb[0]; // if so, copy the values
|
||
|
|
rgb[j][1] = prog_rgb[1];
|
||
|
|
rgb[j][2] = prog_rgb[2];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* LEDs are lit from left to right, which fade out as it passes
|
||
|
|
* then top word then bottom word light, then fade out,
|
||
|
|
* and program repeats.
|
||
|
|
* button: fade rate
|
||
|
|
* knob: hue
|
||
|
|
*/
|
||
|
|
|
||
|
|
#define LITE_INTER_DWELL 20 // time between characters
|
||
|
|
#define LITE_IDLE_DWELL (256+64) // time before changing direction
|
||
|
|
#define LITE_PERSIST 10 // how long to keep each LED at fullbrite
|
||
|
|
|
||
|
|
static uint8_t lite_direction = 0;
|
||
|
|
static uint8_t lite_idx = 0;
|
||
|
|
static uint16_t lite_timeout = 0;
|
||
|
|
static uint8_t lite_persist[9] = {0};
|
||
|
|
|
||
|
|
void led_rgb_1_lite_then_fade(uint8_t preview, uint8_t tick)
|
||
|
|
{
|
||
|
|
uint16_t i, j;
|
||
|
|
uint8_t start, end;
|
||
|
|
|
||
|
|
uint16_t hue = userconf.ledprog_setting[1][1];
|
||
|
|
uint8_t rate = userconf.ledprog_setting[1][0];
|
||
|
|
|
||
|
|
// user sets the color
|
||
|
|
i = 255;
|
||
|
|
if (hue >= 254) {
|
||
|
|
// force white
|
||
|
|
i = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
hue *= 6;
|
||
|
|
hsv2rgb_8b(hue, i, 255, &prog_rgb[0], &prog_rgb[1], &prog_rgb[2]);
|
||
|
|
|
||
|
|
// make the rate adjustment a bit more intuitive
|
||
|
|
if (rate >= 254) rate = 255;
|
||
|
|
else rate >>= 2;
|
||
|
|
|
||
|
|
// fade out anything that's already lit at user's rate
|
||
|
|
for (i = 0; i < 9; i++) {
|
||
|
|
if (lite_persist[i]) lite_persist[i]--;
|
||
|
|
else for (j = 0; j < 2; j++) {
|
||
|
|
if (rgb[i][j] > rate) rgb[i][j] -= rate; else rgb[i][j] = 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// light it up
|
||
|
|
if (!lite_timeout) {
|
||
|
|
if (!lite_direction) {
|
||
|
|
// left to right
|
||
|
|
// light RETRO
|
||
|
|
if (lite_idx < 5) {
|
||
|
|
rgb[lite_idx][0] = prog_rgb[0];
|
||
|
|
rgb[lite_idx][1] = prog_rgb[1];
|
||
|
|
rgb[lite_idx][2] = prog_rgb[2];
|
||
|
|
lite_persist[lite_idx] = LITE_PERSIST;
|
||
|
|
}
|
||
|
|
|
||
|
|
// light TECH
|
||
|
|
if (lite_idx < 4) {
|
||
|
|
rgb[lite_idx + 5][0] = prog_rgb[0];
|
||
|
|
rgb[lite_idx + 5][1] = prog_rgb[1];
|
||
|
|
rgb[lite_idx + 5][2] = prog_rgb[2];
|
||
|
|
lite_persist[lite_idx + 5] = LITE_PERSIST;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
// up to down
|
||
|
|
if (lite_idx < 2) {
|
||
|
|
if (!lite_idx) {
|
||
|
|
start = 0;
|
||
|
|
end = 5;
|
||
|
|
} else {
|
||
|
|
start = 5;
|
||
|
|
end = 9;
|
||
|
|
}
|
||
|
|
|
||
|
|
for (i = start; i < end; i++) {
|
||
|
|
rgb[i][0] = prog_rgb[0];
|
||
|
|
lite_persist[i] = LITE_PERSIST;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// next light
|
||
|
|
lite_idx++;
|
||
|
|
|
||
|
|
end = lite_direction ? 2 : 5;
|
||
|
|
|
||
|
|
// after idle phase, start over in next direction
|
||
|
|
if (lite_idx > end) {
|
||
|
|
lite_idx = 0;
|
||
|
|
lite_direction++;
|
||
|
|
lite_direction &= 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
lite_timeout = lite_direction ? LITE_INTER_DWELL*2 : LITE_INTER_DWELL;
|
||
|
|
|
||
|
|
// at idle phase?
|
||
|
|
if (lite_idx == end) {
|
||
|
|
lite_timeout = LITE_IDLE_DWELL;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
lite_timeout--;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* LEDs are on at some idle level, and random letters will
|
||
|
|
* twinkle by intensifying and shifting hue slightly by a
|
||
|
|
* random small amount.
|
||
|
|
* button: saturation
|
||
|
|
* knob: flashing intensity
|
||
|
|
*/
|
||
|
|
|
||
|
|
#define TWINKLE_PERSIST 3;
|
||
|
|
#define TWINKLE_RGB_VAL 240
|
||
|
|
uint8_t twinkle_set[9] = {0};
|
||
|
|
|
||
|
|
void led_rgb_2_twinkle(uint8_t preview, uint8_t tick)
|
||
|
|
{
|
||
|
|
uint8_t i, j;
|
||
|
|
uint32_t rnd;
|
||
|
|
uint8_t sat;
|
||
|
|
|
||
|
|
// set
|
||
|
|
rnd = prng_get8();
|
||
|
|
if (rnd >= userconf.ledprog_setting[2][1]) {
|
||
|
|
// yup, we're doing it
|
||
|
|
rnd = prng_get16();
|
||
|
|
rnd *= 1536;
|
||
|
|
rnd <<= 16;
|
||
|
|
|
||
|
|
sat = userconf.ledprog_setting[2][0];
|
||
|
|
if (sat >= 128) sat = 128 - (sat - 128);
|
||
|
|
sat <<= 1;
|
||
|
|
|
||
|
|
hsv2rgb_8b(rnd, sat, TWINKLE_RGB_VAL, &prog_rgb[0], &prog_rgb[1], &prog_rgb[2]);
|
||
|
|
|
||
|
|
rnd = prng_get16() & 0xfff;
|
||
|
|
rnd /= 455;
|
||
|
|
|
||
|
|
rgb[rnd][0] = prog_rgb[0];
|
||
|
|
rgb[rnd][1] = prog_rgb[1];
|
||
|
|
rgb[rnd][2] = prog_rgb[2];
|
||
|
|
twinkle_set[rnd] = TWINKLE_PERSIST;
|
||
|
|
}
|
||
|
|
|
||
|
|
// decay
|
||
|
|
for (i = 0; i < 9; i++) {
|
||
|
|
twinkle_set[i]--;
|
||
|
|
for (j = 0; j < 2; j++) {
|
||
|
|
if (twinkle_set[i]) rgb[i][j]--;
|
||
|
|
else rgb[i][j] >>= 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* alternates flashing the words between two colors.
|
||
|
|
* button: offset degrees (360/16)
|
||
|
|
* knob: hue (alternate hue will be either 90 or 180 degrees offset)
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
void led_rgb_3_alternate(uint8_t preview, uint8_t tick)
|
||
|
|
{
|
||
|
|
uint8_t i, j;
|
||
|
|
|
||
|
|
uint16_t hue = userconf.ledprog_setting[3][1] * 6;
|
||
|
|
uint8_t offset = (userconf.ledprog_setting[3][0] & 0xf) * 16 * 6;
|
||
|
|
|
||
|
|
uint8_t is_flashing = 0;
|
||
|
|
|
||
|
|
if (userconf.cursor_color == CONF_CURSOR_OFF) {
|
||
|
|
// flash at ~2Hz
|
||
|
|
tick >>= 5;
|
||
|
|
if (tick & 1) is_flashing = 1;
|
||
|
|
} else {
|
||
|
|
// match cursor
|
||
|
|
if (cursor[userconf.cursor_color]) {
|
||
|
|
is_flashing = 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// set hues
|
||
|
|
for (i = 0; i < 2; i++) {
|
||
|
|
hsv2rgb_8b(hue, 255, 255, &prog_rgb[0], &prog_rgb[1], &prog_rgb[2]);
|
||
|
|
hue += offset;
|
||
|
|
hue %= 1536;
|
||
|
|
|
||
|
|
if (is_flashing) {
|
||
|
|
// set TECH
|
||
|
|
for (j = 5; j < 9; j++) {
|
||
|
|
rgb[j][0] = prog_rgb[0];
|
||
|
|
rgb[j][1] = prog_rgb[1];
|
||
|
|
rgb[j][2] = prog_rgb[2];
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
// set RETRO
|
||
|
|
for (j = 0; j < 5; j++) {
|
||
|
|
rgb[j][0] = prog_rgb[0];
|
||
|
|
rgb[j][1] = prog_rgb[1];
|
||
|
|
rgb[j][2] = prog_rgb[2];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
is_flashing++;
|
||
|
|
is_flashing &= 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* a green, orange or white phosphor sort of "typing,"
|
||
|
|
* with quick but not instant fade-in and flashing of
|
||
|
|
* an active character.
|
||
|
|
* the only program that interferes with the cursor.
|
||
|
|
* after "typing" and filling, the characters fade then
|
||
|
|
* the program repeats.
|
||
|
|
*
|
||
|
|
* no user config for this program
|
||
|
|
*/
|
||
|
|
|
||
|
|
#define TYPING_CHAR_DELAY_MIN 12 // about 1/10 of a second
|
||
|
|
#define TYPING_CHAR_DELAY_MAX 500 // just shy of 4 seconds
|
||
|
|
|
||
|
|
static const uint8_t idle_glow[3] = {12, 8, 8};
|
||
|
|
static const uint8_t typing[3][3] = {
|
||
|
|
{255, 240, 240}, // white
|
||
|
|
{ 0, 240, 0}, // green
|
||
|
|
{255, 96, 12}, // orange
|
||
|
|
};
|
||
|
|
|
||
|
|
static uint8_t typing_idx;
|
||
|
|
static uint16_t typing_char_delay;
|
||
|
|
|
||
|
|
static uint8_t typing_flash_state;
|
||
|
|
static uint8_t typing_flash_delay;
|
||
|
|
|
||
|
|
static uint8_t typing_fadeout;
|
||
|
|
|
||
|
|
|
||
|
|
void led_rgb_4_typing(uint8_t preview, uint8_t tick)
|
||
|
|
{
|
||
|
|
uint8_t i, j;
|
||
|
|
uint8_t w;
|
||
|
|
uint16_t s;
|
||
|
|
uint8_t color;
|
||
|
|
|
||
|
|
// match cursor color (well, approximate, or go green)
|
||
|
|
color = userconf.cursor_color;
|
||
|
|
if (color == CONF_CURSOR_OFF) color = CONF_CURSOR_GREEN;
|
||
|
|
|
||
|
|
// set flash
|
||
|
|
if (!typing_flash_delay) {
|
||
|
|
typing_flash_state++;
|
||
|
|
typing_flash_state &= 1;
|
||
|
|
|
||
|
|
typing_flash_delay = userconf.cursor_flash;
|
||
|
|
}
|
||
|
|
typing_flash_delay--;
|
||
|
|
|
||
|
|
// set rgb colors as appropriate
|
||
|
|
for (i = 0; i < 9; i++) {
|
||
|
|
if (i < typing_idx || ((i == typing_idx) && (typing_flash_state))) {
|
||
|
|
// these are on
|
||
|
|
rgb[i][0] = typing[color][0];
|
||
|
|
rgb[i][1] = typing[color][1];
|
||
|
|
rgb[i][2] = typing[color][2];
|
||
|
|
}
|
||
|
|
|
||
|
|
if (i > typing_idx || ((i == typing_idx) && (!typing_flash_state))) {
|
||
|
|
// these are idle
|
||
|
|
rgb[i][0] = idle_glow[0];
|
||
|
|
rgb[i][1] = idle_glow[1];
|
||
|
|
rgb[i][2] = idle_glow[2];
|
||
|
|
}
|
||
|
|
|
||
|
|
// flashing cursor fadeout
|
||
|
|
if (i == typing_idx && typing_flash_state) {
|
||
|
|
if (typing_flash_delay <= 8) {
|
||
|
|
w = 8 - typing_flash_delay;
|
||
|
|
rgb[i][0] >>= w; if (rgb[i][0] < idle_glow[0]) rgb[i][0] = idle_glow[0];
|
||
|
|
rgb[i][1] >>= w; if (rgb[i][1] < idle_glow[1]) rgb[i][1] = idle_glow[1];
|
||
|
|
rgb[i][2] >>= w; if (rgb[i][2] < idle_glow[2]) rgb[i][2] = idle_glow[2];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// set cursor as appropriate
|
||
|
|
for (i = 0; i < 2; i++) {
|
||
|
|
cursor[i] = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
// at the cursor
|
||
|
|
if (typing_idx >= 9) {
|
||
|
|
cursor[color] = typing_flash_state ? 240 : 12;
|
||
|
|
if (typing_flash_delay <= 8) {
|
||
|
|
w = 8 - typing_flash_delay;
|
||
|
|
cursor[color] >>= w;
|
||
|
|
if (cursor[color] < 12) cursor[color] = 12;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// decay all the characters
|
||
|
|
if (typing_idx == 10) {
|
||
|
|
if (typing_fadeout >= 3) typing_fadeout--;
|
||
|
|
else typing_fadeout = 0;
|
||
|
|
|
||
|
|
for (i = 0; i < 9; i++) {
|
||
|
|
for (j = 0; j < 2; j++) {
|
||
|
|
s = rgb[i][j];
|
||
|
|
s *= typing_fadeout;
|
||
|
|
rgb[i][j] = s >> 8;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
s = cursor[color];
|
||
|
|
s *= typing_fadeout;
|
||
|
|
cursor[color] = s >> 8;
|
||
|
|
}
|
||
|
|
|
||
|
|
// are we on the next character?
|
||
|
|
if (!(--typing_char_delay)) {
|
||
|
|
// next character
|
||
|
|
typing_idx++;
|
||
|
|
|
||
|
|
if (typing_idx == 9) {
|
||
|
|
// at the cursor, we wait two max periods
|
||
|
|
typing_char_delay = TYPING_CHAR_DELAY_MAX << 1;
|
||
|
|
} else if (typing_idx == 10) {
|
||
|
|
// at the end, we wait half of one max period
|
||
|
|
typing_char_delay = TYPING_CHAR_DELAY_MAX >> 1;
|
||
|
|
} else {
|
||
|
|
typing_char_delay = prng_scale16(TYPING_CHAR_DELAY_MIN, TYPING_CHAR_DELAY_MAX);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (typing_idx > 10) typing_idx = 0;
|
||
|
|
|
||
|
|
// reset cursor fade (used in last step)
|
||
|
|
typing_fadeout = 0xff;
|
||
|
|
|
||
|
|
// reset flash state and delay to reset cursor flash
|
||
|
|
// comment this code to keep persistent cursor rate
|
||
|
|
typing_flash_state = 0;
|
||
|
|
typing_flash_delay = 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
* initialize settings for programs before they run
|
||
|
|
* this can be run when changing programs to set them
|
||
|
|
* to a known state before starting over
|
||
|
|
*/
|
||
|
|
void led_rgb_firstrun()
|
||
|
|
{
|
||
|
|
uint8_t i;
|
||
|
|
|
||
|
|
for (i = 0; i < 9; i++) {
|
||
|
|
rgb[i][0] = 0;
|
||
|
|
rgb[i][1] = 0;
|
||
|
|
rgb[i][2] = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
// program 0: rainbow
|
||
|
|
// nothing to set
|
||
|
|
|
||
|
|
// program 1: lite then fade
|
||
|
|
lite_direction = 0;
|
||
|
|
lite_idx = 0;
|
||
|
|
lite_timeout = 0;
|
||
|
|
for (i = 0; i < 9; i++) {
|
||
|
|
lite_persist[i] = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
// program 2: twinkle
|
||
|
|
for (i = 0; i < 9; i++) twinkle_set[i] = 0;
|
||
|
|
|
||
|
|
// program 3: alternating
|
||
|
|
// nothing to set
|
||
|
|
|
||
|
|
// program 4: typing
|
||
|
|
typing_idx = 0;
|
||
|
|
typing_char_delay = prng_scale16(TYPING_CHAR_DELAY_MIN, TYPING_CHAR_DELAY_MAX);
|
||
|
|
|
||
|
|
typing_flash_state = 0;
|
||
|
|
typing_flash_delay = userconf.cursor_flash;
|
||
|
|
}
|