320 lines
6.8 KiB
C
320 lines
6.8 KiB
C
/*
|
|
* Copyright (c) 2020 The ZMK Contributors
|
|
*
|
|
* SPDX-License-Identifier: MIT
|
|
*/
|
|
|
|
#include <device.h>
|
|
#include <init.h>
|
|
#include <kernel.h>
|
|
|
|
#include <math.h>
|
|
#include <stdlib.h>
|
|
|
|
#include <logging/log.h>
|
|
|
|
#include <drivers/led_strip.h>
|
|
#include <device.h>
|
|
|
|
LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
|
|
|
|
#define STRIP_LABEL DT_LABEL(DT_CHOSEN(zmk_underglow))
|
|
#define STRIP_NUM_PIXELS DT_PROP(DT_CHOSEN(zmk_underglow), chain_length)
|
|
|
|
enum rgb_underglow_effect {
|
|
UNDERGLOW_EFFECT_SOLID,
|
|
UNDERGLOW_EFFECT_BREATHE,
|
|
UNDERGLOW_EFFECT_SPECTRUM,
|
|
UNDERGLOW_EFFECT_SWIRL,
|
|
UNDERGLOW_EFFECT_NUMBER // Used to track number of underglow effects
|
|
};
|
|
|
|
struct led_hsb {
|
|
u16_t h;
|
|
u8_t s;
|
|
u8_t b;
|
|
};
|
|
|
|
struct rgb_underglow_state {
|
|
u16_t hue;
|
|
u8_t saturation;
|
|
u8_t brightness;
|
|
u8_t animation_speed;
|
|
u8_t current_effect;
|
|
u16_t animation_step;
|
|
bool on;
|
|
};
|
|
|
|
struct rgb_underglow_state state;
|
|
|
|
struct device *led_strip;
|
|
|
|
struct led_rgb pixels[STRIP_NUM_PIXELS];
|
|
|
|
static struct led_rgb hsb_to_rgb(struct led_hsb hsb)
|
|
{
|
|
double r, g, b;
|
|
|
|
u8_t i = hsb.h / 60;
|
|
double v = hsb.b / 100.0;
|
|
double s = hsb.s / 100.0;
|
|
double f = hsb.h / 360.0 * 6 - i;
|
|
double p = v * (1 - s);
|
|
double q = v * (1 - f * s);
|
|
double t = v * (1 - (1 - f) * s);
|
|
|
|
switch (i % 6)
|
|
{
|
|
case 0: r = v; g = t; b = p; break;
|
|
case 1: r = q; g = v; b = p; break;
|
|
case 2: r = p; g = v; b = t; break;
|
|
case 3: r = p; g = q; b = v; break;
|
|
case 4: r = t; g = p; b = v; break;
|
|
case 5: r = v; g = p; b = q; break;
|
|
}
|
|
|
|
struct led_rgb rgb = { r: r*255, g: g*255, b: b*255 };
|
|
|
|
return rgb;
|
|
}
|
|
|
|
static void zmk_rgb_underglow_effect_solid()
|
|
{
|
|
for (int i=0; i<STRIP_NUM_PIXELS; i++)
|
|
{
|
|
int hue = state.hue;
|
|
int sat = state.saturation;
|
|
int brt = state.brightness;
|
|
|
|
struct led_hsb hsb = { hue, sat, brt };
|
|
|
|
pixels[i] = hsb_to_rgb(hsb);
|
|
}
|
|
}
|
|
|
|
static void zmk_rgb_underglow_effect_breathe()
|
|
{
|
|
for (int i=0; i<STRIP_NUM_PIXELS; i++)
|
|
{
|
|
int hue = state.hue;
|
|
int sat = state.saturation;
|
|
int brt = abs(state.animation_step - 1200) / 12;
|
|
|
|
struct led_hsb hsb = { hue, sat, brt };
|
|
|
|
pixels[i] = hsb_to_rgb(hsb);
|
|
}
|
|
|
|
state.animation_step += state.animation_speed * 10;
|
|
|
|
if (state.animation_step > 2400) {
|
|
state.animation_step = 0;
|
|
}
|
|
}
|
|
|
|
static void zmk_rgb_underglow_effect_spectrum()
|
|
{
|
|
for (int i=0; i<STRIP_NUM_PIXELS; i++)
|
|
{
|
|
int hue = state.animation_step;
|
|
int sat = state.saturation;
|
|
int brt = state.brightness;
|
|
|
|
struct led_hsb hsb = { hue, sat, brt };
|
|
|
|
pixels[i] = hsb_to_rgb(hsb);
|
|
}
|
|
|
|
state.animation_step += state.animation_speed;
|
|
state.animation_step = state.animation_step % 360;
|
|
}
|
|
|
|
static void zmk_rgb_underglow_effect_swirl()
|
|
{
|
|
for (int i=0; i<STRIP_NUM_PIXELS; i++)
|
|
{
|
|
int hue = (360 / STRIP_NUM_PIXELS * i + state.animation_step) % 360;
|
|
int sat = state.saturation;
|
|
int brt = state.brightness;
|
|
|
|
struct led_hsb hsb = { hue, sat, brt };
|
|
|
|
pixels[i] = hsb_to_rgb(hsb);
|
|
}
|
|
|
|
state.animation_step += state.animation_speed * 2;
|
|
state.animation_step = state.animation_step % 360;
|
|
}
|
|
|
|
static void zmk_rgb_underglow_tick(struct k_work *work)
|
|
{
|
|
switch (state.current_effect)
|
|
{
|
|
case UNDERGLOW_EFFECT_SOLID:
|
|
zmk_rgb_underglow_effect_solid();
|
|
break;
|
|
case UNDERGLOW_EFFECT_BREATHE:
|
|
zmk_rgb_underglow_effect_breathe();
|
|
break;
|
|
case UNDERGLOW_EFFECT_SPECTRUM:
|
|
zmk_rgb_underglow_effect_spectrum();
|
|
break;
|
|
case UNDERGLOW_EFFECT_SWIRL:
|
|
zmk_rgb_underglow_effect_swirl();
|
|
break;
|
|
}
|
|
|
|
led_strip_update_rgb(led_strip, pixels, STRIP_NUM_PIXELS);
|
|
}
|
|
|
|
K_WORK_DEFINE(underglow_work, zmk_rgb_underglow_tick);
|
|
|
|
static void zmk_rgb_underglow_tick_handler(struct k_timer *timer)
|
|
{
|
|
k_work_submit(&underglow_work);
|
|
}
|
|
|
|
K_TIMER_DEFINE(underglow_tick, zmk_rgb_underglow_tick_handler, NULL);
|
|
|
|
static int zmk_rgb_underglow_init(struct device *_arg)
|
|
{
|
|
led_strip = device_get_binding(STRIP_LABEL);
|
|
if (led_strip) {
|
|
LOG_INF("Found LED strip device %s", STRIP_LABEL);
|
|
} else {
|
|
LOG_ERR("LED strip device %s not found", STRIP_LABEL);
|
|
return -EINVAL;
|
|
}
|
|
|
|
state = (struct rgb_underglow_state){
|
|
hue: 0,
|
|
saturation: 100,
|
|
brightness: 100,
|
|
animation_speed: 3,
|
|
current_effect: 0,
|
|
animation_step: 0,
|
|
on: true
|
|
};
|
|
|
|
k_timer_start(&underglow_tick, K_NO_WAIT, K_MSEC(50));
|
|
|
|
return 0;
|
|
}
|
|
|
|
int zmk_rgb_underglow_cycle_effect(int direction)
|
|
{
|
|
if (!led_strip) return -ENODEV;
|
|
|
|
if (state.current_effect == 0 && direction < 0) {
|
|
state.current_effect = UNDERGLOW_EFFECT_NUMBER - 1;
|
|
return 0;
|
|
}
|
|
|
|
state.current_effect += direction;
|
|
|
|
if (state.current_effect >= UNDERGLOW_EFFECT_NUMBER) {
|
|
state.current_effect = 0;
|
|
}
|
|
|
|
state.animation_step = 0;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int zmk_rgb_underglow_toggle()
|
|
{
|
|
if (!led_strip) return -ENODEV;
|
|
|
|
state.on = !state.on;
|
|
|
|
if (state.on) {
|
|
state.animation_step = 0;
|
|
k_timer_start(&underglow_tick, K_NO_WAIT, K_MSEC(50));
|
|
} else {
|
|
|
|
for (int i=0; i<STRIP_NUM_PIXELS; i++)
|
|
{
|
|
pixels[i] = (struct led_rgb){ r: 0, g: 0, b: 0};
|
|
}
|
|
|
|
led_strip_update_rgb(led_strip, pixels, STRIP_NUM_PIXELS);
|
|
|
|
k_timer_stop(&underglow_tick);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int zmk_rgb_underglow_change_hue(int direction)
|
|
{
|
|
if (!led_strip) return -ENODEV;
|
|
|
|
if (state.hue == 0 && direction < 0) {
|
|
state.hue = 350;
|
|
return 0;
|
|
}
|
|
|
|
state.hue += direction * CONFIG_ZMK_RGB_UNDERGLOW_HUE_STEP;
|
|
|
|
if (state.hue > 350) {
|
|
state.hue = 0;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int zmk_rgb_underglow_change_sat(int direction)
|
|
{
|
|
if (!led_strip) return -ENODEV;
|
|
|
|
if (state.saturation == 0 && direction < 0) {
|
|
return 0;
|
|
}
|
|
|
|
state.saturation += direction * CONFIG_ZMK_RGB_UNDERGLOW_SAT_STEP;
|
|
|
|
if (state.saturation > 100) {
|
|
state.saturation = 100;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int zmk_rgb_underglow_change_brt(int direction)
|
|
{
|
|
if (!led_strip) return -ENODEV;
|
|
|
|
if (state.brightness == 0 && direction < 0) {
|
|
return 0;
|
|
}
|
|
|
|
state.brightness += direction * CONFIG_ZMK_RGB_UNDERGLOW_BRT_STEP;
|
|
|
|
if (state.brightness > 100) {
|
|
state.brightness = 100;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int zmk_rgb_underglow_change_spd(int direction)
|
|
{
|
|
if (!led_strip) return -ENODEV;
|
|
|
|
if (state.animation_speed == 1 && direction < 0) {
|
|
return 0;
|
|
}
|
|
|
|
state.animation_speed += direction;
|
|
|
|
if (state.animation_speed > 5) {
|
|
state.animation_speed = 5;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
SYS_INIT(zmk_rgb_underglow_init,
|
|
APPLICATION,
|
|
CONFIG_APPLICATION_INIT_PRIORITY);
|