296 lines
7.7 KiB
JavaScript
296 lines
7.7 KiB
JavaScript
import ws281x from "rpi-ws281x";
|
|
import * as fs from "fs";
|
|
import Logger, { levels } from "./logger.js";
|
|
|
|
const cfg = JSON.parse(fs.readFileSync("./config.json"));
|
|
const log = new Logger(
|
|
"lights",
|
|
cfg.log_level ? levels[cfg.log_level] : levels.INFO
|
|
);
|
|
|
|
const fade_ticks = cfg.fade_ticks || 20;
|
|
var pixels = new Uint32Array(cfg.leds);
|
|
var pixel_cache = new Uint32Array(cfg.leds);
|
|
var next_pattern = new Uint32Array(cfg.leds);
|
|
const targets = {};
|
|
var pattern = {};
|
|
|
|
function rgb_to_int(r, g, b) {
|
|
let rgb = r;
|
|
rgb = (rgb << 8) + g;
|
|
rgb = (rgb << 8) + b;
|
|
return rgb;
|
|
}
|
|
function int_to_rgb(int) {
|
|
var r = (int >> 16) & 0xff;
|
|
var g = (int >> 8) & 0xff;
|
|
var b = int & 0xff;
|
|
return { r: r, g: g, b: b };
|
|
}
|
|
|
|
ws281x.configure({
|
|
leds: cfg.leds || 300,
|
|
brightness: cfg.brightness || 200,
|
|
gpio: cfg.gpio || 18,
|
|
stripType: cfg.type || "grb",
|
|
});
|
|
|
|
export function set_pattern(pat) {
|
|
pattern = pat;
|
|
log.debug("pattern set");
|
|
}
|
|
|
|
export class Function {
|
|
func;
|
|
options;
|
|
|
|
constructor(func, options) {
|
|
this.func = func;
|
|
this.options = options;
|
|
}
|
|
}
|
|
|
|
export const functions = {
|
|
random: new Function(
|
|
(index, arg1, arg2) => {
|
|
return Math.floor(Math.random() * 256);
|
|
},
|
|
{
|
|
requires_arg1: true,
|
|
requires_arg2: false,
|
|
convert_args: false,
|
|
}
|
|
),
|
|
move: new Function(
|
|
(index, arg1, arg2) => {
|
|
return arg2;
|
|
},
|
|
{
|
|
requires_arg1: true,
|
|
requires_arg2: true,
|
|
convert_args: true,
|
|
}
|
|
),
|
|
modulo: new Function(
|
|
(index, arg1, arg2) => {
|
|
return arg1 % arg2;
|
|
},
|
|
{
|
|
requires_arg1: true,
|
|
requires_arg2: true,
|
|
convert_args: true,
|
|
}
|
|
),
|
|
swap: new Function(
|
|
(index, arg1, arg2) => {
|
|
let temp = targets[arg2];
|
|
targets[arg2] = targets[arg1];
|
|
return temp;
|
|
},
|
|
{
|
|
requires_arg1: true,
|
|
requires_arg2: true,
|
|
convert_args: false,
|
|
}
|
|
),
|
|
add: new Function(
|
|
(index, arg1, arg2) => {
|
|
return arg1 + arg2;
|
|
},
|
|
{
|
|
requires_arg1: true,
|
|
requires_arg2: true,
|
|
convert_args: true,
|
|
}
|
|
),
|
|
subtract: new Function(
|
|
(index, arg1, arg2) => {
|
|
return arg1 - arg2;
|
|
},
|
|
{
|
|
requires_arg1: true,
|
|
requires_arg2: true,
|
|
convert_args: true,
|
|
}
|
|
),
|
|
slide: new Function(
|
|
(index, arg1, arg2) => {
|
|
return index + arg2;
|
|
},
|
|
{
|
|
requires_arg1: true,
|
|
requires_arg2: true,
|
|
convert_args: true,
|
|
}
|
|
),
|
|
};
|
|
|
|
function tick_pattern() {
|
|
// do the parsing stuff here
|
|
log.debug("TICKING PATTERN");
|
|
|
|
let parsed = pattern.parsed;
|
|
log.debug(`${JSON.stringify(pattern)} ${JSON.stringify(parsed)}`);
|
|
|
|
if (parsed && parsed.length > 0) {
|
|
for (let i = 0; i < cfg.leds; i++) {
|
|
for (let id in parsed) {
|
|
let command = parsed[id];
|
|
log.debug(`pattern ${id} ${command}`);
|
|
let name = command["command"];
|
|
log.debug(`${name} matches: ${functions[name]}`);
|
|
if (functions[name] != undefined) {
|
|
if (
|
|
functions[name].options &&
|
|
functions[name].options["convert_args"]
|
|
) {
|
|
let param_arg1 = parseInt(command.arg1) || targets[command.arg1];
|
|
let param_arg2 = parseInt(command.arg2) || targets[command.arg2];
|
|
let result = functions[name].func(i, param_arg1, param_arg2);
|
|
log.debug(
|
|
`convert ${command.arg1} ${param_arg1} ${command.arg2} ${param_arg2} ${result}`
|
|
);
|
|
targets[command.arg1] = result;
|
|
} else {
|
|
let result = functions[name].func(i, command.arg1, command.arg2);
|
|
log.debug(`no convert ${command.arg1} = ${result}`);
|
|
targets[command.arg1] = result;
|
|
}
|
|
}
|
|
}
|
|
log.debug(`next: ${targets["r"]}, ${targets["g"]}, ${targets["b"]}`);
|
|
next_pattern[i] = rgb_to_int(
|
|
targets["r"] || 0,
|
|
targets["g"] || 0,
|
|
targets["b"] || 0
|
|
);
|
|
targets["r"] = 0;
|
|
targets["g"] = 0;
|
|
targets["b"] = 0;
|
|
}
|
|
} else {
|
|
getRandom();
|
|
}
|
|
}
|
|
|
|
function getRandom() {
|
|
for (let i = 0; i < cfg.leds; i++) {
|
|
var r = Math.floor(Math.random() * 256);
|
|
var g = Math.floor(Math.random() * 256);
|
|
var b = Math.floor(Math.random() * 256);
|
|
next_pattern[i] = rgb_to_int(r, g, b);
|
|
}
|
|
}
|
|
|
|
export function tick() {
|
|
var changed = false;
|
|
for (let i = 0; i < cfg.leds; i++) {
|
|
if (next_pattern[i] != pixels[i]) {
|
|
if (next_pattern[i] == pixel_cache[i]) {
|
|
log.debug("INCONGRUENCE WITH " + i);
|
|
pixels[i] = next_pattern[i];
|
|
} else {
|
|
changed = true;
|
|
fade(i);
|
|
}
|
|
} else if (pixel_cache[i] != pixels[i]) {
|
|
log.debug("PATTERN NOT STORED " + i);
|
|
pixel_cache[i] = pixels[i];
|
|
}
|
|
}
|
|
if (!changed) {
|
|
tick_pattern();
|
|
} else {
|
|
ws281x.render(pixels);
|
|
}
|
|
//ws281x.sleep(cfg.sleep_time || 500);
|
|
}
|
|
|
|
function fade(index) {
|
|
var original = int_to_rgb(pixel_cache[index]);
|
|
var current = int_to_rgb(pixels[index]);
|
|
var final = int_to_rgb(next_pattern[index]);
|
|
var diff_r = final.r - original.r;
|
|
var diff_cr = current.r - original.r;
|
|
var diff_g = final.g - original.g;
|
|
var diff_cg = current.g - original.g;
|
|
var diff_b = final.b - original.b;
|
|
var diff_cb = current.b - original.b;
|
|
var sign_r = diff_r === Math.abs(diff_r) ? 1 : -1;
|
|
var sign_g = diff_g === Math.abs(diff_g) ? 1 : -1;
|
|
var sign_b = diff_b === Math.abs(diff_b) ? 1 : -1;
|
|
log.debug(`${diff_r} ${sign_r} ${diff_g} ${sign_g} ${diff_b} ${sign_b}`);
|
|
var interval_r = sign_r * Math.ceil(Math.abs(diff_r) / fade_ticks);
|
|
var interval_g = sign_g * Math.ceil(Math.abs(diff_g) / fade_ticks);
|
|
var interval_b = sign_b * Math.ceil(Math.abs(diff_b) / fade_ticks);
|
|
log.debug(
|
|
`r${Math.abs(diff_r) / fade_ticks} ${Math.ceil(
|
|
Math.abs(diff_r) / fade_ticks
|
|
)}` +
|
|
`g${Math.abs(diff_g) / fade_ticks} ${Math.ceil(
|
|
Math.abs(diff_g) / fade_ticks
|
|
)}` +
|
|
`b${Math.abs(diff_b) / fade_ticks} ${Math.ceil(
|
|
Math.abs(diff_b) / fade_ticks
|
|
)}`
|
|
);
|
|
|
|
var current_tick_r = Math.floor(Math.abs(diff_cr / diff_r) * fade_ticks);
|
|
var current_tick_g = Math.floor(Math.abs(diff_cg / diff_g) * fade_ticks);
|
|
var current_tick_b = Math.floor(Math.abs(diff_cb / diff_b) * fade_ticks);
|
|
if (
|
|
diff_r == 0 ||
|
|
(sign_r == 1 && current.r + interval_r >= final.r) ||
|
|
(sign_r == -1 && current.r + interval_r <= final.r) ||
|
|
current_tick_r + 1 >= fade_ticks
|
|
) {
|
|
current.r = final.r;
|
|
interval_r = 0;
|
|
current_tick_r = fade_ticks;
|
|
}
|
|
if (
|
|
diff_g == 0 ||
|
|
(sign_g == 1 && current.g + interval_g >= final.g) ||
|
|
(sign_g == -1 && current.g + interval_g <= final.g) ||
|
|
current_tick_g + 1 >= fade_ticks
|
|
) {
|
|
current.g = final.g;
|
|
interval_g = 0;
|
|
current_tick_g = fade_ticks;
|
|
}
|
|
if (
|
|
diff_b == 0 ||
|
|
(sign_b == 1 && current.b + interval_b >= final.b) ||
|
|
(sign_b == -1 && current.b + interval_b <= final.b) ||
|
|
current_tick_b + 1 >= fade_ticks
|
|
) {
|
|
current.b = final.b;
|
|
interval_b = 0;
|
|
current_tick_b = fade_ticks;
|
|
}
|
|
|
|
if (
|
|
current_tick_r + 1 >= fade_ticks &&
|
|
current_tick_g + 1 >= fade_ticks &&
|
|
current_tick_b + 1 >= fade_ticks
|
|
) {
|
|
log.debug("FINISHED");
|
|
pixel_cache[index] = next_pattern[index];
|
|
} else {
|
|
pixels[index] = rgb_to_int(
|
|
current.r + interval_r,
|
|
current.g + interval_g,
|
|
current.b + interval_b
|
|
);
|
|
let prev = int_to_rgb(pixel_cache[index]);
|
|
log.debug(
|
|
`${current_tick_r} ${current_tick_g} ${current_tick_b}: ` +
|
|
`CURRENT COLOR: ${current.r} ${current.g} ${current.b} NEW COLOR: ${
|
|
current.r + interval_r
|
|
} ${current.g + interval_g} ${current.b + interval_b} ` +
|
|
`FINAL: ${final.r} ${final.g} ${final.b} ` +
|
|
`\nINTERVAL: ${interval_r} ${interval_g} ${interval_b} ` +
|
|
`PREVIOUS: ${prev.r} ${prev.g} ${prev.b}`
|
|
);
|
|
}
|
|
}
|