blinky/libs/controller.js

378 lines
12 KiB
JavaScript
Raw Normal View History

2022-02-28 01:53:13 +01:00
const logger = require('./logger.js');
const util = require('./util.js');
const constants = require('./constants.js');
2021-04-06 16:41:49 +02:00
const blinkstick = require('blinkstick');
2022-02-28 01:53:13 +01:00
const LEDAnimations = new Map();
2021-04-06 16:41:49 +02:00
2022-03-04 00:02:07 +01:00
let blinksticks = new Map();
2022-03-04 00:02:07 +01:00
// get connected blinkstick by id (or return the first one found)
async function getBlinkstick(id, filter) {
if (!global.config.blinkstick?.cache || blinksticks.size === 0) {
mapBlinkSticks(filter);
}
if (id === undefined) {
return blinksticks.values().next().value;
}
if (id === constants.ALL) {
return Array.from(blinksticks.values());
}
if (!blinksticks.has(id)) {
throw new Error('could not find any blinkstick matching the given id \'' + id + '\'');
}
return blinksticks.get(id);
}
// map found blinksticks
function mapBlinkSticks(filter) {
const foundBlinksticks = blinkstick.findAll();
if (filter === undefined) {
filter = global.config?.blinkstick?.map?.length > 0;
}
blinksticks = new Map();
filter = filter && global.config.blinkstick?.map?.length > 0;
for (let blinkstickIndex = 0; blinkstickIndex < foundBlinksticks.length; blinkstickIndex++) {
const serial = foundBlinksticks[blinkstickIndex].serial;
if (!filter) {
blinksticks.set(serial, foundBlinksticks[blinkstickIndex]);
continue;
}
for (filterIndex = 0; filterIndex < global.config.blinkstick.map.length; filterIndex++) {
let tmp = global.config.blinkstick.map[filterIndex];
if (tmp.serial !== serial) {
continue;
}
2022-03-04 00:02:07 +01:00
blinksticks.set(tmp.id || serial, foundBlinksticks[blinkstickIndex]);
break;
}
}
if (blinksticks.size === 0) {
2022-03-04 00:02:07 +01:00
if (filter) {
throw new Error('could not find any blinkstick matching the given serial(s)');
} else {
throw new Error('could not find any blinkstick, make sure at least one blinkstick is connected');
}
}
2022-03-04 00:02:07 +01:00
}
// reset a blinkstick
async function resetBlinkstick(id) {
if (blinksticks === undefined || blinksticks.length === 0) {
return;
}
2022-03-04 00:02:07 +01:00
let tmp;
if (id === constants.ALL) {
tmp = await getBlinkstick(id);
for (let index = 0; index < tmp.length; index++) {
if (tmp[index] === undefined) {
continue;
}
tmp[index].close();
}
blinksticks.clear();
} else {
tmp = await getBlinkstick(id);
if (tmp === undefined) {
return;
}
tmp.close();
blinksticks.delete(id);
}
2022-03-04 00:02:07 +01:00
mapBlinkSticks();
2021-04-06 16:41:49 +02:00
}
// simple animation (set the color / morph to color)
async function simple(config) {
2022-02-28 01:53:13 +01:00
await stopLEDsAccordingly(config);
config.timestamp = new Date().getTime();
2022-03-02 00:18:14 +01:00
let indexes = getIndices(config);
for (let index = 0; index < indexes.length; index++) {
2022-02-28 01:53:13 +01:00
const tmpConfig = JSON.parse(JSON.stringify(config));
2022-03-02 00:18:14 +01:00
await singleAnimation(tmpConfig, indexes[index]);
if (index === 0) {
await setColorIfRandom(config);
}
2022-02-22 17:00:30 +01:00
}
return {
status: 'ok',
color: config.color,
2022-03-02 00:18:14 +01:00
indexes: indexes,
time: (new Date().getTime() - config.timestamp) + 'ms'
};
2022-02-22 17:00:30 +01:00
}
// complex animation (pulse / blink)
async function complex(config) {
if (config.timestamp === undefined) {
2022-02-28 01:53:13 +01:00
await stopLEDsAccordingly(config);
config.timestamp = new Date().getTime();
}
2022-03-02 00:18:14 +01:00
let indexes = getIndices(config);
for (let index = 0; index < indexes.length; index++) {
2022-02-28 01:53:13 +01:00
if (shouldLEDFinish(config)) {
clearLedState(config.options.index);
2022-02-25 22:59:01 +01:00
return { status: 'ok', time: (new Date().getTime() - config.timestamp) + 'ms' };
}
2022-02-28 01:53:13 +01:00
const tmpConfig = JSON.parse(JSON.stringify(config));
2022-03-02 00:18:14 +01:00
await singleAnimation(tmpConfig, indexes[index]);
config.repetitions.done++;
2022-02-22 17:00:30 +01:00
}
2022-02-28 01:53:13 +01:00
return await complex(config);
}
// power the blinkstick (or just a specific led) off
async function powerOff(config) {
config.timestamp = new Date().getTime();
if (config.blinkstick === constants.ALL) {
const promises = [];
const blinkstickNames = Array.from(blinksticks.keys());
for (let index = 0; index < blinkstickNames.length; index++) {
const tmp = JSON.parse(JSON.stringify(config));
tmp.blinkstick = blinkstickNames[index];
promises.push(powerOff(tmp));
}
return await Promise.allSettled(promises);
}
2022-03-02 00:18:14 +01:00
let indexes = getIndices(config);
if (config.options.index === constants.ALL) {
LEDAnimations.set(constants.ALL, { stop: new Date().getTime() });
2022-02-28 01:53:13 +01:00
}
2022-03-02 00:18:14 +01:00
for (let index = 0; index < indexes.length; index++) {
await stopLEDAnimation(indexes[index]);
await singleAnimation(JSON.parse(JSON.stringify(config)), indexes[index]);
logger.info('led \'' + indexes[index] + '\' powered off');
}
if (config.options.index === constants.ALL) {
2022-03-04 00:02:07 +01:00
const blinkstick = await getBlinkstick();
blinkstick.turnOff();
2022-02-28 01:53:13 +01:00
LEDAnimations.clear();
logger.info('blinkstick powered off');
}
2022-03-02 00:18:14 +01:00
return { status: 'ok', indexes: indexes, time: (new Date().getTime() - config.timestamp) + 'ms' };
}
// animations
async function singleAnimation(config, index) {
config.options.index = index;
2022-03-04 00:02:07 +01:00
const blinkstick = await getBlinkstick(config.blinkstick);
return await new Promise((resolve, reject) => {
2022-02-28 01:53:13 +01:00
logger.debug('changing color of led \'' + config.options.index + '\' to \'' + config.color + '\' (mode: ' + config.mode + ' | options: ' + JSON.stringify(config.options) + ')...');
setLEDAnimated(config.options.index);
blinkstick.animationsEnabled = true;
switch (config.mode) {
case constants.MODE_MORPH:
blinkstick.morph(config.color, config.options, callback);
break;
case constants.MODE_BLINK:
blinkstick.blink(config.color, config.options, callback);
break;
case constants.MODE_PULSE:
blinkstick.pulse(config.color, config.options, callback);
break;
default:
blinkstick.setColor(config.color, config.options, callback);
break;
}
2022-02-22 17:00:30 +01:00
function callback(err) {
if (config.mode !== constants.MODE_BLINK && config.mode !== constants.MODE_PULSE) {
2022-02-28 01:53:13 +01:00
clearLedState(config.options.index);
}
if (err) {
reject(new Error('changing color of led \'' + config.options.index + '\' to \'' + config.color + '\' encountered an error > ' + err));
}
2022-02-25 22:59:01 +01:00
logger.info('changed color of led \'' + config.options.index + '\' to \'' + config.color + '\' (mode: ' + config.mode + ')');
resolve();
}
});
2022-02-22 17:00:30 +01:00
}
2022-02-28 01:53:13 +01:00
// led / index helper functions
function getIndices(blinkstickConfig) {
if (blinkstickConfig.options.index === constants.ALL) {
2022-02-28 01:53:13 +01:00
return [0, 1, 2, 3, 4, 5, 6, 7];
}
return [blinkstickConfig.options.index];
}
async function getColors(blinkstick, index) {
let blinksticksToCheck = [];
if (blinkstick === undefined) {
blinksticksToCheck = Array.from(blinksticks.keys());
} else {
blinksticksToCheck.push(blinkstick);
}
let indices = [0, 1, 2, 3, 4, 5, 6, 7];
if (index !== undefined && index !== constants.AL && !isNaN(index)) {
index = [index];
}
let results = [];
for (let blinkstickIndex = 0; blinkstickIndex < blinksticksToCheck.length; blinkstickIndex++) {
const tmpBlinkstick = blinksticksToCheck[blinkstickIndex];
let result = {
blinkstick: tmpBlinkstick,
leds: []
};
for (let ledIndex = 0; ledIndex < indices.length; ledIndex++) {
result.leds.push({
index: ledIndex,
color: await getColor({
blinkstick: tmpBlinkstick,
options: {
index: ledIndex
}
})
});
}
results.push(result);
}
return results;
}
2022-03-04 00:02:07 +01:00
async function getColor(config) {
let index = 0;
2022-03-04 00:02:07 +01:00
if (!isNaN(config.options.index)) {
index = parseInt(config.options.index);
}
logger.debug('getting color for led with index \'' + index + '\'');
2022-03-04 00:02:07 +01:00
const blinkstick = await getBlinkstick(config.blinkstick);
return await new Promise((resolve, reject) => {
blinkstick.getColorString(index, (err, color) => {
if (err) {
reject(err);
}
logger.debug('led with index \'' + index + '\' is set to color \'' + color + '\'');
resolve(color);
});
});
}
async function setColorIfRandom(config) {
if (config.options.index !== constants.ALL || config.color !== constants.RANDOM) {
return;
}
2022-03-04 00:02:07 +01:00
config.color = await getColor(config);
}
2022-02-28 01:53:13 +01:00
async function stopLEDsAccordingly(config) {
2022-03-02 00:18:14 +01:00
if (LEDAnimations.size === 0 && config.mode !== constants.MODE_BLINK && config.mode !== constants.MODE_PULSE) {
2022-02-28 01:53:13 +01:00
return;
}
if (config.options.index === constants.ALL) {
2022-02-25 22:59:01 +01:00
logger.debug('stopping all leds...');
return await powerOff({
id: Math.random(),
mode: constants.MODE_POWEROFF,
color: '#000000',
options: { index: constants.ALL }
});
}
2022-02-28 01:53:13 +01:00
return stopLEDAnimation(config.options.index);
}
2022-02-28 01:53:13 +01:00
function shouldLEDFinish(config) {
if (LEDAnimations.has(constants.ALL) || (isLEDAnimated(config.options.index) && isLEDStopping(config.options.index))) {
2022-02-25 22:59:01 +01:00
logger.debug('led \'' + config.options.index + '\' is set to \'stop\' and should finish now');
return true;
}
if (config.mode === constants.MODE_BLINK || config.mode === constants.MODE_PULSE) {
return config.repetitions.max !== 0 && config.repetitions.done >= config.repetitions.max;
}
return false;
}
2022-02-28 01:53:13 +01:00
function setLEDAnimated(index) {
if (isLEDAnimated(index)) {
return;
}
2022-02-28 01:53:13 +01:00
LEDAnimations.set(index, { start: new Date().getTime() });
2022-02-25 22:59:01 +01:00
logger.debug('led \'' + index + '\ set to \'animated\'');
}
2022-02-28 01:53:13 +01:00
function setLEDStopping(index) {
if (!isLEDAnimated(index) || isLEDStopping(index)) {
return;
}
2022-02-28 01:53:13 +01:00
if (LEDAnimations.has(index)) {
LEDAnimations.get(index).stop = new Date().getTime();
}
2022-02-25 22:59:01 +01:00
logger.debug('led \'' + index + '\ set to \'stop\'');
}
function clearLedState(index) {
if (index === constants.ALL) {
2022-02-28 01:53:13 +01:00
LEDAnimations.clear();
2022-02-25 22:59:01 +01:00
logger.debug('cleared animation state of all leds');
return;
}
2022-02-28 01:53:13 +01:00
LEDAnimations.delete(index);
2022-02-25 22:59:01 +01:00
logger.debug('cleared animation state of led \'' + index + '\'');
}
2022-02-28 01:53:13 +01:00
function isLEDAnimated(index) {
return LEDAnimations.has(index);
}
2022-02-28 01:53:13 +01:00
function isLEDStopping(index) {
if (LEDAnimations.has(constants.ALL) && LEDAnimations.get(constants.ALL).stop !== undefined) {
2022-02-28 01:53:13 +01:00
return true;
}
if (LEDAnimations.has(index) && LEDAnimations.get(index).stop !== undefined) {
return true;
}
2022-02-28 01:53:13 +01:00
return false;
}
2022-02-28 01:53:13 +01:00
async function stopLEDAnimation(index) {
if (index === constants.ALL) {
2022-02-28 01:53:13 +01:00
for (const [key, value] of LEDAnimations) {
setLEDStopping(key);
}
await waitForAllAnimationsEnd();
return;
}
setLEDStopping(index);
await waitForAnimationEnd(index);
}
2022-02-28 01:53:13 +01:00
async function waitForAnimationEnd(index, timestamp) {
2022-02-25 22:59:01 +01:00
logger.debug('waiting for animated led \'' + index + '\' to end...');
2022-02-28 01:53:13 +01:00
if (!isLEDAnimated(index)) {
2022-02-25 22:59:01 +01:00
logger.debug('animation of led \'' + index + '\' should have ended now');
2022-02-28 01:53:13 +01:00
return;
}
2022-02-28 01:53:13 +01:00
if (timestamp === undefined) {
timestamp = new Date().getTime();
}
await util.sleep(100);
return await waitForAnimationEnd(index, timestamp);
}
2022-02-28 01:53:13 +01:00
async function waitForAllAnimationsEnd(callback, timestamp) {
if (LEDAnimations.size === 0) {
return;
}
2022-02-25 22:59:01 +01:00
logger.debug('waiting for all animations to end...');
2022-02-28 01:53:13 +01:00
for (const [key, value] of LEDAnimations) {
await waitForAnimationEnd(key);
2021-04-06 16:41:49 +02:00
}
}
function isInfiniteAnimation(config) {
if (config.mode !== constants.MODE_BLINK && config.mode !== constants.MODE_PULSE) {
return false;
2021-04-06 16:41:49 +02:00
}
return config.repetitions.max === 0;
2021-04-06 16:41:49 +02:00
}
// exports
module.exports = {
getBlinkstick,
2022-03-04 00:02:07 +01:00
mapBlinkSticks,
simple,
complex,
powerOff,
isInfiniteAnimation,
getColors
}