759 lines
23 KiB
JavaScript
759 lines
23 KiB
JavaScript
const mqtt = require("mqtt");
|
|
const hardware = require("./hardware");
|
|
const { app } = require("electron");
|
|
|
|
global.INTEGRATION = global.INTEGRATION || {
|
|
initialized: false,
|
|
status: "offline",
|
|
};
|
|
|
|
/**
|
|
* Initializes the integration with the provided arguments.
|
|
*
|
|
* @param {Object} args - The command-line arguments to customize the initialization process.
|
|
* @returns {boolean} Returns true if the initialization was successful.
|
|
*/
|
|
const init = async (args) => {
|
|
if (!args.mqtt_url) {
|
|
return false;
|
|
}
|
|
const url = new URL(args.mqtt_url);
|
|
const user = args.mqtt_user ? args.mqtt_user : null;
|
|
const password = args.mqtt_password ? args.mqtt_password : null;
|
|
const discovery = args.mqtt_discovery ? args.mqtt_discovery : "homeassistant";
|
|
|
|
const model = hardware.getModel();
|
|
const vendor = hardware.getVendor();
|
|
const hostName = hardware.getHostName();
|
|
const serialNumber = hardware.getSerialNumber();
|
|
const serialNumberSuffix = serialNumber.slice(-6);
|
|
|
|
const deviceId = serialNumberSuffix.toUpperCase().replace(/[^A-Z0-9]/g, "");
|
|
const deviceName = hostName.charAt(0).toUpperCase() + hostName.slice(1);
|
|
|
|
// Init globals
|
|
INTEGRATION.node = `rpi_${deviceId}`;
|
|
INTEGRATION.discovery = discovery;
|
|
INTEGRATION.device = {
|
|
name: `TouchKio ${deviceName}`,
|
|
model: model,
|
|
manufacturer: vendor,
|
|
serial_number: serialNumber,
|
|
identifiers: [INTEGRATION.node],
|
|
sw_version: `${app.getName()}-v${app.getVersion()}`,
|
|
};
|
|
|
|
// Connection settings
|
|
const options = user === null || password == null ? null : { username: user, password: password };
|
|
const masked = password === null ? "null" : "*".repeat(password.length);
|
|
console.log("MQTT Connecting:", `${user}:${masked}@${url.toString()}`);
|
|
INTEGRATION.client = mqtt.connect(url.toString(), options);
|
|
|
|
// Client connected
|
|
INTEGRATION.client
|
|
.on("connect", () => {
|
|
console.log(`MQTT Connected: ${url.toString()}\n`);
|
|
|
|
// Init client controls
|
|
initShutdown(INTEGRATION.client);
|
|
initReboot(INTEGRATION.client);
|
|
initRefresh(INTEGRATION.client);
|
|
initKiosk(INTEGRATION.client);
|
|
initDisplay(INTEGRATION.client);
|
|
initKeyboard(INTEGRATION.client);
|
|
|
|
// Init client sensors
|
|
initModel(INTEGRATION.client);
|
|
initSerialNumber(INTEGRATION.client);
|
|
initHostName(INTEGRATION.client);
|
|
initUpTime(INTEGRATION.client);
|
|
initMemorySize(INTEGRATION.client);
|
|
initMemoryUsage(INTEGRATION.client);
|
|
initProcessorUsage(INTEGRATION.client);
|
|
initProcessorTemperature(INTEGRATION.client);
|
|
initPackageUpgrades(INTEGRATION.client);
|
|
initHeartbeat(INTEGRATION.client);
|
|
initLastActive(INTEGRATION.client);
|
|
|
|
// Integration initialized
|
|
INTEGRATION.initialized = true;
|
|
INTEGRATION.status = "online";
|
|
})
|
|
.on("error", (error) => {
|
|
console.error("MQTT:", error);
|
|
INTEGRATION.status = "offline";
|
|
});
|
|
|
|
// Update sensor states from notifiers
|
|
HARDWARE.display.notifiers.push(() => {
|
|
updateDisplay(INTEGRATION.client);
|
|
});
|
|
HARDWARE.keyboard.notifiers.push(() => {
|
|
updateKeyboard(INTEGRATION.client);
|
|
});
|
|
|
|
// Update time sensors periodically (30s)
|
|
setInterval(() => {
|
|
updateHeartbeat(INTEGRATION.client);
|
|
updateLastActive(INTEGRATION.client);
|
|
}, 30 * 1000);
|
|
|
|
// Update system sensors periodically (1min)
|
|
setInterval(() => {
|
|
update();
|
|
}, 60 * 1000);
|
|
|
|
// Update package sensors periodically (60min)
|
|
setInterval(() => {
|
|
updatePackageUpgrades(INTEGRATION.client);
|
|
}, 3600 * 1000);
|
|
|
|
return true;
|
|
};
|
|
|
|
/**
|
|
* Updates the shared integration properties.
|
|
*/
|
|
const update = () => {
|
|
if (!INTEGRATION.initialized) {
|
|
return;
|
|
}
|
|
|
|
// Update client sensors
|
|
updateKiosk(INTEGRATION.client);
|
|
updateUpTime(INTEGRATION.client);
|
|
updateLastActive(INTEGRATION.client);
|
|
updateMemoryUsage(INTEGRATION.client);
|
|
updateProcessorUsage(INTEGRATION.client);
|
|
updateProcessorTemperature(INTEGRATION.client);
|
|
};
|
|
|
|
/**
|
|
* Initializes the shutdown button and handles the execute logic.
|
|
*
|
|
* @param {Object} client - Instance of the mqtt client.
|
|
*/
|
|
const initShutdown = (client) => {
|
|
const root = `${INTEGRATION.discovery}/button/${INTEGRATION.node}/shutdown`;
|
|
const config = {
|
|
name: "Shutdown",
|
|
unique_id: `${INTEGRATION.node}_shutdown`,
|
|
command_topic: `${root}/execute`,
|
|
icon: "mdi:power",
|
|
device: INTEGRATION.device,
|
|
};
|
|
client
|
|
.publish(`${root}/config`, JSON.stringify(config), { qos: 1, retain: true })
|
|
.on("message", (topic, message) => {
|
|
if (topic === `${root}/execute`) {
|
|
console.log("Shutdown system...");
|
|
hardware.setDisplayStatus("ON");
|
|
hardware.shutdownSystem();
|
|
}
|
|
})
|
|
.subscribe(`${root}/execute`);
|
|
};
|
|
|
|
/**
|
|
* Initializes the reboot button and handles the execute logic.
|
|
*
|
|
* @param {Object} client - Instance of the mqtt client.
|
|
*/
|
|
const initReboot = (client) => {
|
|
const root = `${INTEGRATION.discovery}/button/${INTEGRATION.node}/reboot`;
|
|
const config = {
|
|
name: "Reboot",
|
|
unique_id: `${INTEGRATION.node}_reboot`,
|
|
command_topic: `${root}/execute`,
|
|
icon: "mdi:restart",
|
|
device: INTEGRATION.device,
|
|
};
|
|
client
|
|
.publish(`${root}/config`, JSON.stringify(config), { qos: 1, retain: true })
|
|
.on("message", (topic, message) => {
|
|
if (topic === `${root}/execute`) {
|
|
console.log("Rebooting system...");
|
|
hardware.setDisplayStatus("ON");
|
|
hardware.rebootSystem();
|
|
}
|
|
})
|
|
.subscribe(`${root}/execute`);
|
|
};
|
|
|
|
/**
|
|
* Initializes the refresh button and handles the execute logic.
|
|
*
|
|
* @param {Object} client - Instance of the mqtt client.
|
|
*/
|
|
const initRefresh = (client) => {
|
|
const root = `${INTEGRATION.discovery}/button/${INTEGRATION.node}/refresh`;
|
|
const config = {
|
|
name: "Refresh",
|
|
unique_id: `${INTEGRATION.node}_refresh`,
|
|
command_topic: `${root}/execute`,
|
|
icon: "mdi:web-refresh",
|
|
device: INTEGRATION.device,
|
|
};
|
|
client
|
|
.publish(`${root}/config`, JSON.stringify(config), { qos: 1, retain: true })
|
|
.on("message", (topic, message) => {
|
|
if (topic === `${root}/execute`) {
|
|
console.log("Refreshing webview...");
|
|
hardware.setDisplayStatus("ON");
|
|
WEBVIEW.view.webContents.reloadIgnoringCache();
|
|
}
|
|
})
|
|
.subscribe(`${root}/execute`);
|
|
};
|
|
|
|
/**
|
|
* Initializes the kiosk select status and handles the execute logic.
|
|
*
|
|
* @param {Object} client - Instance of the mqtt client.
|
|
*/
|
|
const initKiosk = (client) => {
|
|
const root = `${INTEGRATION.discovery}/select/${INTEGRATION.node}/kiosk`;
|
|
const config = {
|
|
name: `Kiosk`,
|
|
unique_id: `${INTEGRATION.node}_kiosk`,
|
|
command_topic: `${root}/set`,
|
|
state_topic: `${root}/status`,
|
|
value_template: "{{ value }}",
|
|
options: ["Framed", "Fullscreen", "Maximized", "Minimized", "Terminated"],
|
|
icon: "mdi:overscan",
|
|
device: INTEGRATION.device,
|
|
};
|
|
client
|
|
.publish(`${root}/config`, JSON.stringify(config), { qos: 1, retain: true })
|
|
.on("message", (topic, message) => {
|
|
if (topic === `${root}/set`) {
|
|
const status = message.toString();
|
|
console.log("Set Kiosk Status:", status);
|
|
hardware.setDisplayStatus("ON");
|
|
switch (status) {
|
|
case "Framed":
|
|
WEBVIEW.window.restore();
|
|
WEBVIEW.window.unmaximize();
|
|
WEBVIEW.window.setFullScreen(false);
|
|
break;
|
|
case "Fullscreen":
|
|
WEBVIEW.window.restore();
|
|
WEBVIEW.window.unmaximize();
|
|
WEBVIEW.window.setFullScreen(true);
|
|
break;
|
|
case "Maximized":
|
|
WEBVIEW.window.restore();
|
|
WEBVIEW.window.setFullScreen(false);
|
|
WEBVIEW.window.maximize();
|
|
break;
|
|
case "Minimized":
|
|
WEBVIEW.window.restore();
|
|
WEBVIEW.window.setFullScreen(false);
|
|
WEBVIEW.window.minimize();
|
|
break;
|
|
case "Terminated":
|
|
app.quit();
|
|
}
|
|
}
|
|
})
|
|
.subscribe(`${root}/set`);
|
|
updateKiosk(client);
|
|
};
|
|
|
|
/**
|
|
* Updates the kiosk status via the mqtt connection.
|
|
*
|
|
* @param {Object} client - Instance of the mqtt client.
|
|
*/
|
|
const updateKiosk = (client) => {
|
|
const kiosk = WEBVIEW.status;
|
|
const root = `${INTEGRATION.discovery}/select/${INTEGRATION.node}/kiosk`;
|
|
if (kiosk !== null) {
|
|
client.publish(`${root}/status`, `${kiosk}`, { qos: 1, retain: true });
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Initializes the display status, brightness and handles the execute logic.
|
|
*
|
|
* @param {Object} client - Instance of the mqtt client.
|
|
*/
|
|
const initDisplay = (client) => {
|
|
if (!HARDWARE.support.displayStatus) {
|
|
return;
|
|
}
|
|
const root = `${INTEGRATION.discovery}/light/${INTEGRATION.node}/display`;
|
|
const config = {
|
|
name: `Display`,
|
|
unique_id: `${INTEGRATION.node}_display`,
|
|
command_topic: `${root}/set`,
|
|
state_topic: `${root}/status`,
|
|
icon: "mdi:monitor-shimmer",
|
|
platform: "light",
|
|
device: INTEGRATION.device,
|
|
};
|
|
if (HARDWARE.support.displayBrightness) {
|
|
config.brightness_scale = 100;
|
|
config.brightness_command_topic = `${root}/brightness/set`;
|
|
config.brightness_state_topic = `${root}/brightness/status`;
|
|
}
|
|
client
|
|
.publish(`${root}/config`, JSON.stringify(config), { qos: 1, retain: true })
|
|
.on("message", (topic, message) => {
|
|
if (topic === `${root}/set`) {
|
|
const status = message.toString();
|
|
console.log("Set Display Status:", status);
|
|
hardware.setDisplayStatus(status);
|
|
} else if (topic === `${root}/brightness/set`) {
|
|
const brightness = parseInt(message, 10);
|
|
console.log("Set Display Brightness:", brightness);
|
|
hardware.setDisplayBrightness(brightness);
|
|
}
|
|
})
|
|
.subscribe(`${root}/set`)
|
|
.subscribe(`${root}/brightness/set`);
|
|
updateDisplay(client);
|
|
};
|
|
|
|
/**
|
|
* Updates the display status, brightness via the mqtt connection.
|
|
*
|
|
* @param {Object} client - Instance of the mqtt client.
|
|
*/
|
|
const updateDisplay = (client) => {
|
|
const status = hardware.getDisplayStatus();
|
|
const brightness = hardware.getDisplayBrightness();
|
|
const root = `${INTEGRATION.discovery}/light/${INTEGRATION.node}/display`;
|
|
if (status !== null) {
|
|
client.publish(`${root}/status`, `${status}`, { qos: 1, retain: true });
|
|
}
|
|
if (brightness !== null) {
|
|
client.publish(`${root}/brightness/status`, `${brightness}`, { qos: 1, retain: true });
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Initializes the keyboard visibility and handles the execute logic.
|
|
*
|
|
* @param {Object} client - Instance of the mqtt client.
|
|
*/
|
|
const initKeyboard = (client) => {
|
|
if (!HARDWARE.support.keyboardVisibility) {
|
|
return;
|
|
}
|
|
const root = `${INTEGRATION.discovery}/switch/${INTEGRATION.node}/keyboard`;
|
|
const config = {
|
|
name: `Keyboard`,
|
|
unique_id: `${INTEGRATION.node}_keyboard`,
|
|
command_topic: `${root}/set`,
|
|
state_topic: `${root}/status`,
|
|
icon: "mdi:keyboard-close",
|
|
device: INTEGRATION.device,
|
|
};
|
|
client
|
|
.publish(`${root}/config`, JSON.stringify(config), { qos: 1, retain: true })
|
|
.on("message", (topic, message) => {
|
|
if (topic === `${root}/set`) {
|
|
const status = message.toString();
|
|
console.log("Set Keyboard Visibility:", status);
|
|
hardware.setKeyboardVisibility(status);
|
|
switch (status) {
|
|
case "OFF":
|
|
WEBVIEW.window.restore();
|
|
WEBVIEW.window.unmaximize();
|
|
WEBVIEW.window.setFullScreen(true);
|
|
break;
|
|
case "ON":
|
|
WEBVIEW.window.restore();
|
|
WEBVIEW.window.setFullScreen(false);
|
|
WEBVIEW.window.maximize();
|
|
break;
|
|
}
|
|
}
|
|
})
|
|
.subscribe(`${root}/set`);
|
|
updateKeyboard(client);
|
|
};
|
|
|
|
/**
|
|
* Updates the keyboard visibility via the mqtt connection.
|
|
*
|
|
* @param {Object} client - Instance of the mqtt client.
|
|
*/
|
|
const updateKeyboard = (client) => {
|
|
const visibility = hardware.getKeyboardVisibility();
|
|
const root = `${INTEGRATION.discovery}/switch/${INTEGRATION.node}/keyboard`;
|
|
if (visibility !== null) {
|
|
client.publish(`${root}/status`, `${visibility}`, { qos: 1, retain: true });
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Initializes the model sensor.
|
|
*
|
|
* @param {Object} client - Instance of the mqtt client.
|
|
*/
|
|
const initModel = (client) => {
|
|
const root = `${INTEGRATION.discovery}/sensor/${INTEGRATION.node}/model`;
|
|
const config = {
|
|
name: `Model`,
|
|
unique_id: `${INTEGRATION.node}_model`,
|
|
state_topic: `${root}/status`,
|
|
value_template: "{{ value }}",
|
|
icon: "mdi:raspberry-pi",
|
|
device: INTEGRATION.device,
|
|
};
|
|
client.publish(`${root}/config`, JSON.stringify(config), { qos: 1, retain: true });
|
|
updateModel(client);
|
|
};
|
|
|
|
/**
|
|
* Updates the model sensor via the mqtt connection.
|
|
*
|
|
* @param {Object} client - Instance of the mqtt client.
|
|
*/
|
|
const updateModel = (client) => {
|
|
const model = hardware.getModel();
|
|
const root = `${INTEGRATION.discovery}/sensor/${INTEGRATION.node}/model`;
|
|
if (model !== null) {
|
|
client.publish(`${root}/status`, `${model}`, { qos: 1, retain: true });
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Initializes the serial number sensor.
|
|
*
|
|
* @param {Object} client - Instance of the mqtt client.
|
|
*/
|
|
const initSerialNumber = (client) => {
|
|
const root = `${INTEGRATION.discovery}/sensor/${INTEGRATION.node}/serial_number`;
|
|
const config = {
|
|
name: `Serial Number`,
|
|
unique_id: `${INTEGRATION.node}_serial_number`,
|
|
state_topic: `${root}/status`,
|
|
value_template: "{{ value }}",
|
|
icon: "mdi:hexadecimal",
|
|
device: INTEGRATION.device,
|
|
};
|
|
client.publish(`${root}/config`, JSON.stringify(config), { qos: 1, retain: true });
|
|
updateSerialNumber(client);
|
|
};
|
|
|
|
/**
|
|
* Updates the serial number sensor via the mqtt connection.
|
|
*
|
|
* @param {Object} client - Instance of the mqtt client.
|
|
*/
|
|
const updateSerialNumber = (client) => {
|
|
const serialNumber = hardware.getSerialNumber();
|
|
const root = `${INTEGRATION.discovery}/sensor/${INTEGRATION.node}/serial_number`;
|
|
if (serialNumber !== null) {
|
|
client.publish(`${root}/status`, `${serialNumber}`, { qos: 1, retain: true });
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Initializes the host name sensor.
|
|
*
|
|
* @param {Object} client - Instance of the mqtt client.
|
|
*/
|
|
const initHostName = (client) => {
|
|
const root = `${INTEGRATION.discovery}/sensor/${INTEGRATION.node}/host_name`;
|
|
const config = {
|
|
name: `Host Name`,
|
|
unique_id: `${INTEGRATION.node}_host_name`,
|
|
state_topic: `${root}/status`,
|
|
value_template: "{{ value }}",
|
|
icon: "mdi:console-network",
|
|
device: INTEGRATION.device,
|
|
};
|
|
client.publish(`${root}/config`, JSON.stringify(config), { qos: 1, retain: true });
|
|
updateHostName(client);
|
|
};
|
|
|
|
/**
|
|
* Updates the host name sensor via the mqtt connection.
|
|
*
|
|
* @param {Object} client - Instance of the mqtt client.
|
|
*/
|
|
const updateHostName = (client) => {
|
|
const hostName = hardware.getHostName();
|
|
const root = `${INTEGRATION.discovery}/sensor/${INTEGRATION.node}/host_name`;
|
|
if (hostName !== null) {
|
|
client.publish(`${root}/status`, `${hostName}`, { qos: 1, retain: true });
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Initializes the up time sensor.
|
|
*
|
|
* @param {Object} client - Instance of the mqtt client.
|
|
*/
|
|
const initUpTime = (client) => {
|
|
const root = `${INTEGRATION.discovery}/sensor/${INTEGRATION.node}/up_time`;
|
|
const config = {
|
|
name: `Up Time`,
|
|
unique_id: `${INTEGRATION.node}_up_time`,
|
|
state_topic: `${root}/status`,
|
|
value_template: "{{ (value | float) | round(0) }}",
|
|
unit_of_measurement: "min",
|
|
icon: "mdi:timeline-clock",
|
|
device: INTEGRATION.device,
|
|
};
|
|
client.publish(`${root}/config`, JSON.stringify(config), { qos: 1, retain: true });
|
|
updateUpTime(client);
|
|
};
|
|
|
|
/**
|
|
* Updates the up time sensor via the mqtt connection.
|
|
*
|
|
* @param {Object} client - Instance of the mqtt client.
|
|
*/
|
|
const updateUpTime = (client) => {
|
|
const upTime = hardware.getUpTime();
|
|
const root = `${INTEGRATION.discovery}/sensor/${INTEGRATION.node}/up_time`;
|
|
if (upTime !== null) {
|
|
client.publish(`${root}/status`, `${upTime}`, { qos: 1, retain: true });
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Initializes the memory size sensor.
|
|
*
|
|
* @param {Object} client - Instance of the mqtt client.
|
|
*/
|
|
const initMemorySize = (client) => {
|
|
const root = `${INTEGRATION.discovery}/sensor/${INTEGRATION.node}/memory_size`;
|
|
const config = {
|
|
name: `Memory Size`,
|
|
unique_id: `${INTEGRATION.node}_memory_size`,
|
|
state_topic: `${root}/status`,
|
|
value_template: "{{ (value | float) | round(2) }}",
|
|
unit_of_measurement: "GiB",
|
|
icon: "mdi:memory",
|
|
device: INTEGRATION.device,
|
|
};
|
|
client.publish(`${root}/config`, JSON.stringify(config), { qos: 1, retain: true });
|
|
updateMemorySize(client);
|
|
};
|
|
|
|
/**
|
|
* Updates the memory size sensor via the mqtt connection.
|
|
*
|
|
* @param {Object} client - Instance of the mqtt client.
|
|
*/
|
|
const updateMemorySize = (client) => {
|
|
const memorySize = hardware.getMemorySize();
|
|
const root = `${INTEGRATION.discovery}/sensor/${INTEGRATION.node}/memory_size`;
|
|
if (memorySize !== null) {
|
|
client.publish(`${root}/status`, `${memorySize}`, { qos: 1, retain: true });
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Initializes the memory usage sensor.
|
|
*
|
|
* @param {Object} client - Instance of the mqtt client.
|
|
*/
|
|
const initMemoryUsage = (client) => {
|
|
const root = `${INTEGRATION.discovery}/sensor/${INTEGRATION.node}/memory_usage`;
|
|
const config = {
|
|
name: `Memory Usage`,
|
|
unique_id: `${INTEGRATION.node}_memory_usage`,
|
|
state_topic: `${root}/status`,
|
|
value_template: "{{ (value | float) | round(0) }}",
|
|
unit_of_measurement: "%",
|
|
icon: "mdi:memory-arrow-down",
|
|
device: INTEGRATION.device,
|
|
};
|
|
client.publish(`${root}/config`, JSON.stringify(config), { qos: 1, retain: true });
|
|
updateMemoryUsage(client);
|
|
};
|
|
|
|
/**
|
|
* Updates the memory usage sensor via the mqtt connection.
|
|
*
|
|
* @param {Object} client - Instance of the mqtt client.
|
|
*/
|
|
const updateMemoryUsage = (client) => {
|
|
const memoryUsage = hardware.getMemoryUsage();
|
|
const root = `${INTEGRATION.discovery}/sensor/${INTEGRATION.node}/memory_usage`;
|
|
if (memoryUsage !== null) {
|
|
client.publish(`${root}/status`, `${memoryUsage}`, { qos: 1, retain: true });
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Initializes the processor usage sensor.
|
|
*
|
|
* @param {Object} client - Instance of the mqtt client.
|
|
*/
|
|
const initProcessorUsage = (client) => {
|
|
const root = `${INTEGRATION.discovery}/sensor/${INTEGRATION.node}/processor_usage`;
|
|
const config = {
|
|
name: `Processor Usage`,
|
|
unique_id: `${INTEGRATION.node}_processor_usage`,
|
|
state_topic: `${root}/status`,
|
|
value_template: "{{ (value | float) | round(0) }}",
|
|
unit_of_measurement: "%",
|
|
icon: "mdi:cpu-64-bit",
|
|
device: INTEGRATION.device,
|
|
};
|
|
client.publish(`${root}/config`, JSON.stringify(config), { qos: 1, retain: true });
|
|
updateProcessorUsage(client);
|
|
};
|
|
|
|
/**
|
|
* Updates the processor usage sensor via the mqtt connection.
|
|
*
|
|
* @param {Object} client - Instance of the mqtt client.
|
|
*/
|
|
const updateProcessorUsage = (client) => {
|
|
const processorUsage = hardware.getProcessorUsage();
|
|
const root = `${INTEGRATION.discovery}/sensor/${INTEGRATION.node}/processor_usage`;
|
|
if (processorUsage !== null) {
|
|
client.publish(`${root}/status`, `${processorUsage}`, { qos: 1, retain: true });
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Initializes the processor temperature sensor.
|
|
*
|
|
* @param {Object} client - Instance of the mqtt client.
|
|
*/
|
|
const initProcessorTemperature = (client) => {
|
|
const root = `${INTEGRATION.discovery}/sensor/${INTEGRATION.node}/processor_temperature`;
|
|
const config = {
|
|
name: `Processor Temperature`,
|
|
unique_id: `${INTEGRATION.node}_processor_temperature`,
|
|
state_topic: `${root}/status`,
|
|
value_template: "{{ (value | float) | round(0) }}",
|
|
unit_of_measurement: "°C",
|
|
icon: "mdi:radiator",
|
|
device: INTEGRATION.device,
|
|
};
|
|
client.publish(`${root}/config`, JSON.stringify(config), { qos: 1, retain: true });
|
|
updateProcessorTemperature(client);
|
|
};
|
|
|
|
/**
|
|
* Updates the processor temperature sensor via the mqtt connection.
|
|
*
|
|
* @param {Object} client - Instance of the mqtt client.
|
|
*/
|
|
const updateProcessorTemperature = (client) => {
|
|
const processorTemperature = hardware.getProcessorTemperature();
|
|
const root = `${INTEGRATION.discovery}/sensor/${INTEGRATION.node}/processor_temperature`;
|
|
if (processorTemperature !== null) {
|
|
client.publish(`${root}/status`, `${processorTemperature}`, { qos: 1, retain: true });
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Initializes the package upgrades sensor.
|
|
*
|
|
* @param {Object} client - Instance of the mqtt client.
|
|
*/
|
|
const initPackageUpgrades = (client) => {
|
|
const root = `${INTEGRATION.discovery}/sensor/${INTEGRATION.node}/package_upgrades`;
|
|
const config = {
|
|
name: `Package Upgrades`,
|
|
unique_id: `${INTEGRATION.node}_package_upgrades`,
|
|
state_topic: `${root}/status`,
|
|
json_attributes_topic: `${root}/attributes`,
|
|
value_template: "{{ value }}",
|
|
icon: "mdi:package-down",
|
|
device: INTEGRATION.device,
|
|
};
|
|
client.publish(`${root}/config`, JSON.stringify(config), { qos: 1, retain: true });
|
|
updatePackageUpgrades(client);
|
|
};
|
|
|
|
/**
|
|
* Updates the package upgrades sensor via the mqtt connection.
|
|
*
|
|
* @param {Object} client - Instance of the mqtt client.
|
|
*/
|
|
const updatePackageUpgrades = (client) => {
|
|
const packages = hardware.checkPackageUpgrades();
|
|
const root = `${INTEGRATION.discovery}/sensor/${INTEGRATION.node}/package_upgrades`;
|
|
if (packages !== null) {
|
|
const attributes = {
|
|
total: packages.length,
|
|
packages: packages.map((pkg) => pkg.replace(/\s*\[.*?\]\s*/g, "").trim()),
|
|
};
|
|
client.publish(`${root}/status`, `${attributes.total}`, { qos: 1, retain: true });
|
|
client.publish(`${root}/attributes`, JSON.stringify(attributes), { qos: 1, retain: true });
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Initializes the heartbeat sensor.
|
|
*
|
|
* @param {Object} client - Instance of the mqtt client.
|
|
*/
|
|
const initHeartbeat = (client) => {
|
|
const root = `${INTEGRATION.discovery}/sensor/${INTEGRATION.node}/heartbeat`;
|
|
const config = {
|
|
name: `Heartbeat`,
|
|
unique_id: `${INTEGRATION.node}_heartbeat`,
|
|
state_topic: `${root}/status`,
|
|
value_template: "{{ value }}",
|
|
icon: "mdi:heart-flash",
|
|
device: INTEGRATION.device,
|
|
};
|
|
client.publish(`${root}/config`, JSON.stringify(config), { qos: 1, retain: true });
|
|
updateHeartbeat(client);
|
|
};
|
|
|
|
/**
|
|
* Updates the heartbeat sensor via the mqtt connection.
|
|
*
|
|
* @param {Object} client - Instance of the mqtt client.
|
|
*/
|
|
const updateHeartbeat = (client) => {
|
|
const now = new Date();
|
|
const local = new Date(now.getTime() - now.getTimezoneOffset() * 60 * 1000);
|
|
const heartbeat = local.toISOString().replace(/\.\d{3}Z$/, "");
|
|
const root = `${INTEGRATION.discovery}/sensor/${INTEGRATION.node}/heartbeat`;
|
|
client.publish(`${root}/status`, `${heartbeat}`, { qos: 1, retain: true });
|
|
};
|
|
|
|
/**
|
|
* Initializes the last active sensor.
|
|
*
|
|
* @param {Object} client - Instance of the mqtt client.
|
|
*/
|
|
const initLastActive = (client) => {
|
|
const root = `${INTEGRATION.discovery}/sensor/${INTEGRATION.node}/last_active`;
|
|
const config = {
|
|
name: `Last Active`,
|
|
unique_id: `${INTEGRATION.node}_last_active`,
|
|
state_topic: `${root}/status`,
|
|
value_template: "{{ (value | float) | round(0) }}",
|
|
unit_of_measurement: "min",
|
|
icon: "mdi:gesture-tap-hold",
|
|
device: INTEGRATION.device,
|
|
};
|
|
client.publish(`${root}/config`, JSON.stringify(config), { qos: 1, retain: true });
|
|
updateLastActive(client);
|
|
};
|
|
|
|
/**
|
|
* Updates the last active sensor via the mqtt connection.
|
|
*
|
|
* @param {Object} client - Instance of the mqtt client.
|
|
*/
|
|
const updateLastActive = (client) => {
|
|
const now = new Date();
|
|
const then = WEBVIEW.pointer.time;
|
|
const lastActive = Math.abs(now - then) / (1000 * 60);
|
|
const root = `${INTEGRATION.discovery}/sensor/${INTEGRATION.node}/last_active`;
|
|
client.publish(`${root}/status`, `${lastActive}`, { qos: 1, retain: true });
|
|
};
|
|
|
|
module.exports = {
|
|
init,
|
|
update,
|
|
};
|