1150 lines
32 KiB
JavaScript
1150 lines
32 KiB
JavaScript
const { contextBridge, ipcRenderer } = require("electron");
|
|
const crypto = require("node:crypto");
|
|
const dgram = require("node:dgram");
|
|
const fs = require("node:fs/promises");
|
|
const os = require("node:os");
|
|
const { pathToFileURL } = require("node:url");
|
|
function loadOptionalDependency(packageName) {
|
|
try {
|
|
return {
|
|
module: require(packageName),
|
|
error: null
|
|
};
|
|
} catch (error) {
|
|
console.error(`[time4midi] Optional dependency "${packageName}" failed to load:`, error);
|
|
return {
|
|
module: null,
|
|
error
|
|
};
|
|
}
|
|
}
|
|
|
|
const mqttDependency = loadOptionalDependency("mqtt");
|
|
const serialportDependency = loadOptionalDependency("serialport");
|
|
const modbusDependency = loadOptionalDependency("modbus-serial");
|
|
const knxDependency = loadOptionalDependency("knx");
|
|
|
|
const mqtt = mqttDependency.module;
|
|
const SerialPort = serialportDependency.module?.SerialPort || null;
|
|
const ModbusRTU = modbusDependency.module || null;
|
|
const knx = knxDependency.module || null;
|
|
|
|
const ARTNET_PORT = 6454;
|
|
const SACN_PORT = 5568;
|
|
const KNX_PORT = 3671;
|
|
const ARTNET_HEADER = Buffer.from("Art-Net\0", "ascii");
|
|
const ARTNET_OPCODE_DMX = 0x5000;
|
|
const ARTNET_OPCODE_TIMECODE = 0x9700;
|
|
|
|
function createStatusEmitter() {
|
|
return {
|
|
statusListeners: new Set(),
|
|
lastError: ""
|
|
};
|
|
}
|
|
|
|
function emitStatus(target, message) {
|
|
target.lastError = message || "";
|
|
const payload = {
|
|
ok: !target.lastError,
|
|
error: target.lastError
|
|
};
|
|
for (const listener of target.statusListeners) {
|
|
listener(payload);
|
|
}
|
|
}
|
|
|
|
function dependencyError(label, dependency) {
|
|
const detail = dependency.error?.message || "Modul nicht verfuegbar";
|
|
return new Error(`${label} Modul nicht verfuegbar: ${detail}`);
|
|
}
|
|
|
|
function addStatusApi(target, handler) {
|
|
target.statusListeners.add(handler);
|
|
handler({
|
|
ok: !target.lastError,
|
|
error: target.lastError
|
|
});
|
|
return () => {
|
|
target.statusListeners.delete(handler);
|
|
};
|
|
}
|
|
|
|
const artnet = {
|
|
...createStatusEmitter(),
|
|
sendSocket: null,
|
|
sendSocketSignature: "",
|
|
listenSocket: null,
|
|
listeners: new Set(),
|
|
config: {
|
|
enabled: true,
|
|
localAddress: "",
|
|
host: "255.255.255.255",
|
|
port: ARTNET_PORT,
|
|
broadcast: true,
|
|
timecodeListenPort: ARTNET_PORT
|
|
},
|
|
sequence: 1
|
|
};
|
|
|
|
const sacn = {
|
|
...createStatusEmitter(),
|
|
socket: null,
|
|
socketSignature: "",
|
|
config: {
|
|
enabled: false,
|
|
localAddress: "",
|
|
host: "",
|
|
port: SACN_PORT,
|
|
multicast: true,
|
|
sourceName: "Time4Midi"
|
|
},
|
|
sequence: 1,
|
|
cid: crypto.randomBytes(16)
|
|
};
|
|
|
|
const osc = {
|
|
...createStatusEmitter(),
|
|
socket: null,
|
|
socketSignature: "",
|
|
config: {
|
|
enabled: false,
|
|
localAddress: "",
|
|
host: "127.0.0.1",
|
|
port: 8000
|
|
}
|
|
};
|
|
|
|
const mqttState = {
|
|
...createStatusEmitter(),
|
|
client: null,
|
|
connected: false,
|
|
config: {
|
|
enabled: false,
|
|
localAddress: "",
|
|
brokerUrl: "mqtt://127.0.0.1:1883",
|
|
username: "",
|
|
password: "",
|
|
clientId: ""
|
|
}
|
|
};
|
|
|
|
const serialState = {
|
|
...createStatusEmitter(),
|
|
port: null,
|
|
config: {
|
|
enabled: false,
|
|
path: "",
|
|
baudRate: 9600,
|
|
dataBits: 8,
|
|
stopBits: 1,
|
|
parity: "none",
|
|
mode: "rs232"
|
|
}
|
|
};
|
|
|
|
const modbusTcpState = {
|
|
...createStatusEmitter(),
|
|
client: null,
|
|
connected: false,
|
|
signature: "",
|
|
config: {
|
|
enabled: false,
|
|
localAddress: "",
|
|
host: "127.0.0.1",
|
|
port: 502,
|
|
timeout: 1000
|
|
}
|
|
};
|
|
|
|
const modbusRtuState = {
|
|
...createStatusEmitter(),
|
|
client: null,
|
|
connected: false,
|
|
signature: "",
|
|
config: {
|
|
enabled: false,
|
|
path: "",
|
|
baudRate: 9600,
|
|
dataBits: 8,
|
|
stopBits: 1,
|
|
parity: "none",
|
|
timeout: 1000
|
|
}
|
|
};
|
|
|
|
const knxState = {
|
|
...createStatusEmitter(),
|
|
connection: null,
|
|
connecting: null,
|
|
connected: false,
|
|
config: {
|
|
enabled: false,
|
|
interface: "",
|
|
ipAddr: "224.0.23.12",
|
|
ipPort: KNX_PORT,
|
|
physAddr: "15.15.15",
|
|
forceTunneling: false
|
|
}
|
|
};
|
|
|
|
function normalizeArtNetConfig(nextConfig = {}) {
|
|
return {
|
|
enabled: nextConfig.enabled !== false,
|
|
localAddress: String(nextConfig.localAddress || "").trim(),
|
|
host: nextConfig.host || "255.255.255.255",
|
|
port: Number.isFinite(Number(nextConfig.port)) ? Number(nextConfig.port) : ARTNET_PORT,
|
|
broadcast: Boolean(nextConfig.broadcast),
|
|
timecodeListenPort: Number.isFinite(Number(nextConfig.timecodeListenPort))
|
|
? Number(nextConfig.timecodeListenPort)
|
|
: ARTNET_PORT
|
|
};
|
|
}
|
|
|
|
function normalizeSacnConfig(nextConfig = {}) {
|
|
return {
|
|
enabled: Boolean(nextConfig.enabled),
|
|
localAddress: String(nextConfig.localAddress || "").trim(),
|
|
host: String(nextConfig.host || ""),
|
|
port: Number.isFinite(Number(nextConfig.port)) ? Number(nextConfig.port) : SACN_PORT,
|
|
multicast: nextConfig.multicast !== false,
|
|
sourceName: String(nextConfig.sourceName || "Time4Midi").slice(0, 63)
|
|
};
|
|
}
|
|
|
|
function normalizeOscConfig(nextConfig = {}) {
|
|
return {
|
|
enabled: Boolean(nextConfig.enabled),
|
|
localAddress: String(nextConfig.localAddress || "").trim(),
|
|
host: nextConfig.host || "127.0.0.1",
|
|
port: Number.isFinite(Number(nextConfig.port)) ? Number(nextConfig.port) : 8000
|
|
};
|
|
}
|
|
|
|
function normalizeMqttConfig(nextConfig = {}) {
|
|
return {
|
|
enabled: Boolean(nextConfig.enabled),
|
|
localAddress: String(nextConfig.localAddress || "").trim(),
|
|
brokerUrl: String(nextConfig.brokerUrl || "").trim() || "mqtt://127.0.0.1:1883",
|
|
username: String(nextConfig.username || ""),
|
|
password: String(nextConfig.password || ""),
|
|
clientId: String(nextConfig.clientId || "")
|
|
};
|
|
}
|
|
|
|
function normalizeSerialConfig(nextConfig = {}) {
|
|
return {
|
|
enabled: Boolean(nextConfig.enabled),
|
|
path: String(nextConfig.path || ""),
|
|
baudRate: Number.isFinite(Number(nextConfig.baudRate)) ? Number(nextConfig.baudRate) : 9600,
|
|
dataBits: [7, 8].includes(Number(nextConfig.dataBits)) ? Number(nextConfig.dataBits) : 8,
|
|
stopBits: [1, 2].includes(Number(nextConfig.stopBits)) ? Number(nextConfig.stopBits) : 1,
|
|
parity: ["none", "even", "odd"].includes(String(nextConfig.parity || "none")) ? String(nextConfig.parity || "none") : "none",
|
|
mode: String(nextConfig.mode || "rs232")
|
|
};
|
|
}
|
|
|
|
function normalizeModbusTcpConfig(nextConfig = {}) {
|
|
return {
|
|
enabled: Boolean(nextConfig.enabled),
|
|
localAddress: String(nextConfig.localAddress || "").trim(),
|
|
host: String(nextConfig.host || "127.0.0.1"),
|
|
port: Number.isFinite(Number(nextConfig.port)) ? Number(nextConfig.port) : 502,
|
|
timeout: Number.isFinite(Number(nextConfig.timeout)) ? Number(nextConfig.timeout) : 1000
|
|
};
|
|
}
|
|
|
|
function normalizeModbusRtuConfig(nextConfig = {}) {
|
|
return {
|
|
enabled: Boolean(nextConfig.enabled),
|
|
path: String(nextConfig.path || ""),
|
|
baudRate: Number.isFinite(Number(nextConfig.baudRate)) ? Number(nextConfig.baudRate) : 9600,
|
|
dataBits: [7, 8].includes(Number(nextConfig.dataBits)) ? Number(nextConfig.dataBits) : 8,
|
|
stopBits: [1, 2].includes(Number(nextConfig.stopBits)) ? Number(nextConfig.stopBits) : 1,
|
|
parity: ["none", "even", "odd"].includes(String(nextConfig.parity || "none")) ? String(nextConfig.parity || "none") : "none",
|
|
timeout: Number.isFinite(Number(nextConfig.timeout)) ? Number(nextConfig.timeout) : 1000
|
|
};
|
|
}
|
|
|
|
function normalizeKnxConfig(nextConfig = {}) {
|
|
return {
|
|
enabled: Boolean(nextConfig.enabled),
|
|
interface: String(nextConfig.interface || "").trim(),
|
|
ipAddr: String(nextConfig.ipAddr || "224.0.23.12"),
|
|
ipPort: Number.isFinite(Number(nextConfig.ipPort)) ? Number(nextConfig.ipPort) : KNX_PORT,
|
|
physAddr: String(nextConfig.physAddr || "15.15.15"),
|
|
forceTunneling: Boolean(nextConfig.forceTunneling)
|
|
};
|
|
}
|
|
|
|
function createUdpSocket(target, label) {
|
|
const socket = dgram.createSocket("udp4");
|
|
socket.on("error", (error) => {
|
|
emitStatus(target, `${label} Socket Fehler: ${error.message}`);
|
|
});
|
|
return socket;
|
|
}
|
|
|
|
function closeUdpSocket(target, key, signatureKey) {
|
|
if (target[key]) {
|
|
try {
|
|
target[key].close();
|
|
} catch (_error) {
|
|
// Ignore close races while reconfiguring sockets.
|
|
}
|
|
}
|
|
target[key] = null;
|
|
target[signatureKey] = "";
|
|
}
|
|
|
|
async function ensureUdpSocket(target, key, signatureKey, label, config, options = {}) {
|
|
const signature = `${config.localAddress || ""}|${options.broadcast ? "1" : "0"}`;
|
|
if (target[key] && target[signatureKey] === signature) {
|
|
return target[key];
|
|
}
|
|
|
|
closeUdpSocket(target, key, signatureKey);
|
|
const socket = createUdpSocket(target, label);
|
|
target[key] = socket;
|
|
target[signatureKey] = signature;
|
|
|
|
if (options.broadcast) {
|
|
socket.setBroadcast(true);
|
|
}
|
|
|
|
if (!config.localAddress) {
|
|
return socket;
|
|
}
|
|
|
|
await new Promise((resolve, reject) => {
|
|
let settled = false;
|
|
const handleError = (error) => {
|
|
if (settled) {
|
|
return;
|
|
}
|
|
settled = true;
|
|
socket.off("listening", handleListening);
|
|
reject(error);
|
|
};
|
|
const handleListening = () => {
|
|
if (settled) {
|
|
return;
|
|
}
|
|
settled = true;
|
|
socket.off("error", handleError);
|
|
resolve(true);
|
|
};
|
|
|
|
socket.once("error", handleError);
|
|
socket.once("listening", handleListening);
|
|
try {
|
|
socket.bind(0, config.localAddress);
|
|
} catch (error) {
|
|
socket.off("error", handleError);
|
|
socket.off("listening", handleListening);
|
|
reject(error);
|
|
}
|
|
});
|
|
|
|
emitStatus(target, "");
|
|
return socket;
|
|
}
|
|
|
|
function closeArtNetListener() {
|
|
if (artnet.listenSocket) {
|
|
try {
|
|
artnet.listenSocket.close();
|
|
} catch (_error) {
|
|
// Ignore listener close races.
|
|
}
|
|
artnet.listenSocket = null;
|
|
}
|
|
}
|
|
|
|
function parseArtNetTimecode(message) {
|
|
if (message.length < 19) {
|
|
return null;
|
|
}
|
|
if (!message.subarray(0, 8).equals(ARTNET_HEADER)) {
|
|
return null;
|
|
}
|
|
const opcode = message.readUInt16LE(8);
|
|
if (opcode !== ARTNET_OPCODE_TIMECODE) {
|
|
return null;
|
|
}
|
|
|
|
const frames = message[14];
|
|
const seconds = message[15];
|
|
const minutes = message[16];
|
|
const hours = message[17];
|
|
const frameType = message[18] & 0x03;
|
|
const fpsMap = [24, 25, 29.97, 30];
|
|
const fps = fpsMap[frameType] || 30;
|
|
const totalSeconds = (hours * 3600) + (minutes * 60) + seconds + (frames / fps);
|
|
return { hours, minutes, seconds, frames, fps, totalSeconds };
|
|
}
|
|
|
|
function ensureArtNetListener() {
|
|
if (!artnet.config.enabled || artnet.listenSocket) {
|
|
return;
|
|
}
|
|
|
|
artnet.listenSocket = createUdpSocket(artnet, "Art-Net");
|
|
artnet.listenSocket.on("listening", () => {
|
|
emitStatus(artnet, "");
|
|
});
|
|
artnet.listenSocket.on("message", (message) => {
|
|
const parsed = parseArtNetTimecode(message);
|
|
if (!parsed) return;
|
|
for (const listener of artnet.listeners) {
|
|
listener(parsed);
|
|
}
|
|
});
|
|
|
|
try {
|
|
if (artnet.config.localAddress) {
|
|
artnet.listenSocket.bind(artnet.config.timecodeListenPort, artnet.config.localAddress);
|
|
} else {
|
|
artnet.listenSocket.bind(artnet.config.timecodeListenPort);
|
|
}
|
|
} catch (error) {
|
|
emitStatus(artnet, `Art-Net Listen Fehler: ${error.message}`);
|
|
}
|
|
}
|
|
|
|
function configureArtNet(nextConfig) {
|
|
const previousPort = artnet.config.timecodeListenPort;
|
|
const previousLocalAddress = artnet.config.localAddress;
|
|
artnet.config = normalizeArtNetConfig(nextConfig);
|
|
|
|
if (!artnet.config.enabled) {
|
|
closeArtNetListener();
|
|
closeUdpSocket(artnet, "sendSocket", "sendSocketSignature");
|
|
emitStatus(artnet, "");
|
|
return artnet.config;
|
|
}
|
|
|
|
if (
|
|
previousPort !== artnet.config.timecodeListenPort
|
|
|| previousLocalAddress !== artnet.config.localAddress
|
|
) {
|
|
closeArtNetListener();
|
|
}
|
|
if (
|
|
artnet.sendSocket
|
|
&& (
|
|
previousLocalAddress !== artnet.config.localAddress
|
|
|| Boolean(artnet.config.broadcast) !== artnet.sendSocketSignature.endsWith("|1")
|
|
)
|
|
) {
|
|
closeUdpSocket(artnet, "sendSocket", "sendSocketSignature");
|
|
}
|
|
if (artnet.listeners.size > 0) {
|
|
ensureArtNetListener();
|
|
}
|
|
return artnet.config;
|
|
}
|
|
|
|
async function sendArtNetDmx(payload) {
|
|
if (!artnet.config.enabled) {
|
|
return false;
|
|
}
|
|
|
|
const universe = Math.max(0, Math.min(32767, Number(payload.universe) || 0));
|
|
const values = Array.isArray(payload.values) ? payload.values : [];
|
|
const length = Math.max(2, Math.min(512, values.length || 512));
|
|
const evenLength = length % 2 === 0 ? length : length + 1;
|
|
const packet = Buffer.alloc(18 + evenLength);
|
|
|
|
ARTNET_HEADER.copy(packet, 0);
|
|
packet.writeUInt16LE(ARTNET_OPCODE_DMX, 8);
|
|
packet[10] = 0x00;
|
|
packet[11] = 0x0e;
|
|
packet[12] = artnet.sequence;
|
|
packet[13] = 0x00;
|
|
packet.writeUInt16LE(universe, 14);
|
|
packet.writeUInt16BE(evenLength, 16);
|
|
for (let index = 0; index < evenLength; index += 1) {
|
|
packet[18 + index] = Math.max(0, Math.min(255, Math.round(values[index] || 0)));
|
|
}
|
|
artnet.sequence = artnet.sequence >= 255 ? 1 : artnet.sequence + 1;
|
|
|
|
const socket = await ensureUdpSocket(
|
|
artnet,
|
|
"sendSocket",
|
|
"sendSocketSignature",
|
|
"Art-Net",
|
|
artnet.config,
|
|
{ broadcast: artnet.config.broadcast }
|
|
);
|
|
|
|
return new Promise((resolve, reject) => {
|
|
socket.send(packet, 0, packet.length, artnet.config.port, artnet.config.host, (error) => {
|
|
if (error) {
|
|
emitStatus(artnet, `Art-Net Send Fehler: ${error.message}`);
|
|
reject(error);
|
|
return;
|
|
}
|
|
emitStatus(artnet, "");
|
|
resolve(true);
|
|
});
|
|
});
|
|
}
|
|
|
|
function configureOsc(nextConfig) {
|
|
const previousLocalAddress = osc.config.localAddress;
|
|
osc.config = normalizeOscConfig(nextConfig);
|
|
if (previousLocalAddress !== osc.config.localAddress) {
|
|
closeUdpSocket(osc, "socket", "socketSignature");
|
|
}
|
|
emitStatus(osc, "");
|
|
return osc.config;
|
|
}
|
|
|
|
function encodeOscString(value) {
|
|
const base = Buffer.from(`${value}\0`, "utf8");
|
|
const padding = (4 - (base.length % 4)) % 4;
|
|
return padding === 0 ? base : Buffer.concat([base, Buffer.alloc(padding)]);
|
|
}
|
|
|
|
function encodeOscArgument(value, argType) {
|
|
if (argType === "string") {
|
|
return { tag: "s", data: encodeOscString(String(value ?? "")) };
|
|
}
|
|
if (argType === "int") {
|
|
const data = Buffer.alloc(4);
|
|
data.writeInt32BE(Math.round(Number(value) || 0), 0);
|
|
return { tag: "i", data };
|
|
}
|
|
const data = Buffer.alloc(4);
|
|
data.writeFloatBE(Number(value) || 0, 0);
|
|
return { tag: "f", data };
|
|
}
|
|
|
|
async function sendOsc(payload) {
|
|
if (!osc.config.enabled) {
|
|
return false;
|
|
}
|
|
const address = String(payload.address || "/time4midi");
|
|
const normalizedAddress = address.startsWith("/") ? address : `/${address}`;
|
|
const argument = encodeOscArgument(payload.value, payload.argType || "float");
|
|
const packet = Buffer.concat([
|
|
encodeOscString(normalizedAddress),
|
|
encodeOscString(`,${argument.tag}`),
|
|
argument.data
|
|
]);
|
|
const socket = await ensureUdpSocket(osc, "socket", "socketSignature", "OSC", osc.config);
|
|
return new Promise((resolve, reject) => {
|
|
socket.send(packet, 0, packet.length, osc.config.port, osc.config.host, (error) => {
|
|
if (error) {
|
|
emitStatus(osc, `OSC Send Fehler: ${error.message}`);
|
|
reject(error);
|
|
return;
|
|
}
|
|
emitStatus(osc, "");
|
|
resolve(true);
|
|
});
|
|
});
|
|
}
|
|
|
|
function configureSacn(nextConfig) {
|
|
const previousLocalAddress = sacn.config.localAddress;
|
|
sacn.config = normalizeSacnConfig(nextConfig);
|
|
if (previousLocalAddress !== sacn.config.localAddress) {
|
|
closeUdpSocket(sacn, "socket", "socketSignature");
|
|
}
|
|
emitStatus(sacn, "");
|
|
return sacn.config;
|
|
}
|
|
|
|
function clampSacnUniverse(universe) {
|
|
return Math.max(1, Math.min(63999, Number(universe) || 1));
|
|
}
|
|
|
|
function sacnDestination(universe) {
|
|
const safeUniverse = clampSacnUniverse(universe);
|
|
if (!sacn.config.multicast) {
|
|
return sacn.config.host || "127.0.0.1";
|
|
}
|
|
const high = (safeUniverse >> 8) & 0xff;
|
|
const low = safeUniverse & 0xff;
|
|
return `239.255.${high}.${low}`;
|
|
}
|
|
|
|
function encodeFlagsAndLength(length) {
|
|
return 0x7000 | length;
|
|
}
|
|
|
|
function writeFixedString(buffer, offset, size, value) {
|
|
buffer.fill(0, offset, offset + size);
|
|
Buffer.from(String(value || ""), "utf8").copy(buffer, offset, 0, size);
|
|
}
|
|
|
|
async function sendSacnDmx(payload) {
|
|
if (!sacn.config.enabled) {
|
|
return false;
|
|
}
|
|
|
|
const universe = clampSacnUniverse(payload.universe);
|
|
const values = Array.isArray(payload.values) ? payload.values : [];
|
|
const slotCount = Math.max(1, Math.min(512, values.length || 512));
|
|
const packetLength = 126 + slotCount;
|
|
const propertyValueCount = slotCount + 1;
|
|
const packet = Buffer.alloc(packetLength);
|
|
|
|
packet.writeUInt16BE(0x0010, 0);
|
|
packet.writeUInt16BE(0x0000, 2);
|
|
writeFixedString(packet, 4, 12, "ASC-E1.17");
|
|
|
|
packet.writeUInt16BE(encodeFlagsAndLength(packetLength - 16), 16);
|
|
packet.writeUInt32BE(0x00000004, 18);
|
|
sacn.cid.copy(packet, 22);
|
|
|
|
packet.writeUInt16BE(encodeFlagsAndLength(packetLength - 38), 38);
|
|
packet.writeUInt32BE(0x00000002, 40);
|
|
writeFixedString(packet, 44, 64, sacn.config.sourceName || "Time4Midi");
|
|
packet[108] = 100;
|
|
packet.writeUInt16BE(0x0000, 109);
|
|
packet[111] = sacn.sequence;
|
|
packet[112] = 0x00;
|
|
packet.writeUInt16BE(universe, 113);
|
|
|
|
packet.writeUInt16BE(encodeFlagsAndLength(packetLength - 115), 115);
|
|
packet[117] = 0x02;
|
|
packet[118] = 0xa1;
|
|
packet.writeUInt16BE(0x0000, 119);
|
|
packet.writeUInt16BE(0x0001, 121);
|
|
packet.writeUInt16BE(propertyValueCount, 123);
|
|
packet[125] = 0x00;
|
|
|
|
for (let index = 0; index < slotCount; index += 1) {
|
|
packet[126 + index] = Math.max(0, Math.min(255, Math.round(values[index] || 0)));
|
|
}
|
|
|
|
sacn.sequence = sacn.sequence >= 255 ? 1 : sacn.sequence + 1;
|
|
const host = sacnDestination(universe);
|
|
const socket = await ensureUdpSocket(sacn, "socket", "socketSignature", "sACN", sacn.config);
|
|
|
|
return new Promise((resolve, reject) => {
|
|
socket.send(packet, 0, packet.length, sacn.config.port, host, (error) => {
|
|
if (error) {
|
|
emitStatus(sacn, `sACN Send Fehler: ${error.message}`);
|
|
reject(error);
|
|
return;
|
|
}
|
|
emitStatus(sacn, "");
|
|
resolve(true);
|
|
});
|
|
});
|
|
}
|
|
|
|
function disconnectMqtt() {
|
|
if (mqttState.client) {
|
|
try {
|
|
mqttState.client.removeAllListeners();
|
|
mqttState.client.end(true);
|
|
} catch (_error) {
|
|
// Best effort disconnect.
|
|
}
|
|
}
|
|
mqttState.client = null;
|
|
mqttState.connected = false;
|
|
}
|
|
|
|
function configureMqtt(nextConfig) {
|
|
mqttState.config = normalizeMqttConfig(nextConfig);
|
|
disconnectMqtt();
|
|
|
|
if (!mqttState.config.enabled) {
|
|
emitStatus(mqttState, "");
|
|
return mqttState.config;
|
|
}
|
|
|
|
if (!mqtt) {
|
|
emitStatus(mqttState, dependencyError("MQTT", mqttDependency).message);
|
|
return mqttState.config;
|
|
}
|
|
|
|
const options = { reconnectPeriod: 1000 };
|
|
if (mqttState.config.clientId) options.clientId = mqttState.config.clientId;
|
|
if (mqttState.config.username) options.username = mqttState.config.username;
|
|
if (mqttState.config.password) options.password = mqttState.config.password;
|
|
if (mqttState.config.localAddress) options.localAddress = mqttState.config.localAddress;
|
|
|
|
try {
|
|
mqttState.client = mqtt.connect(mqttState.config.brokerUrl, options);
|
|
mqttState.client.on("connect", () => {
|
|
mqttState.connected = true;
|
|
emitStatus(mqttState, "");
|
|
});
|
|
mqttState.client.on("reconnect", () => {
|
|
mqttState.connected = false;
|
|
emitStatus(mqttState, "MQTT verbindet neu...");
|
|
});
|
|
mqttState.client.on("close", () => {
|
|
mqttState.connected = false;
|
|
});
|
|
mqttState.client.on("error", (error) => {
|
|
mqttState.connected = false;
|
|
emitStatus(mqttState, `MQTT Fehler: ${error.message}`);
|
|
});
|
|
} catch (error) {
|
|
emitStatus(mqttState, `MQTT Fehler: ${error.message}`);
|
|
}
|
|
|
|
return mqttState.config;
|
|
}
|
|
|
|
function publishMqtt(payload) {
|
|
if (!mqttState.config.enabled) {
|
|
return Promise.resolve(false);
|
|
}
|
|
return new Promise((resolve, reject) => {
|
|
if (!mqttState.client || !mqttState.connected) {
|
|
reject(new Error("MQTT nicht verbunden"));
|
|
return;
|
|
}
|
|
mqttState.client.publish(String(payload.topic || ""), String(payload.value ?? ""), {}, (error) => {
|
|
if (error) {
|
|
emitStatus(mqttState, `MQTT Send Fehler: ${error.message}`);
|
|
reject(error);
|
|
return;
|
|
}
|
|
emitStatus(mqttState, "");
|
|
resolve(true);
|
|
});
|
|
});
|
|
}
|
|
|
|
function closeSerialPort() {
|
|
return new Promise((resolve) => {
|
|
if (!serialState.port) {
|
|
resolve();
|
|
return;
|
|
}
|
|
const port = serialState.port;
|
|
serialState.port = null;
|
|
if (!port.isOpen) {
|
|
resolve();
|
|
return;
|
|
}
|
|
port.close(() => resolve());
|
|
});
|
|
}
|
|
|
|
async function configureSerial(nextConfig) {
|
|
serialState.config = normalizeSerialConfig(nextConfig);
|
|
await closeSerialPort();
|
|
if (serialState.config.enabled && !SerialPort) {
|
|
emitStatus(serialState, dependencyError("Serial", serialportDependency).message);
|
|
return serialState.config;
|
|
}
|
|
emitStatus(serialState, "");
|
|
return serialState.config;
|
|
}
|
|
|
|
async function ensureSerialPortOpen() {
|
|
if (!SerialPort) {
|
|
throw dependencyError("Serial", serialportDependency);
|
|
}
|
|
if (!serialState.config.enabled) {
|
|
throw new Error("Serial deaktiviert");
|
|
}
|
|
if (!serialState.config.path) {
|
|
throw new Error("Serial Port nicht gesetzt");
|
|
}
|
|
if (serialState.port && serialState.port.isOpen && serialState.port.path === serialState.config.path) {
|
|
return serialState.port;
|
|
}
|
|
await closeSerialPort();
|
|
|
|
serialState.port = new SerialPort({
|
|
path: serialState.config.path,
|
|
baudRate: serialState.config.baudRate,
|
|
dataBits: serialState.config.dataBits,
|
|
stopBits: serialState.config.stopBits,
|
|
parity: serialState.config.parity,
|
|
autoOpen: false
|
|
});
|
|
|
|
serialState.port.on("error", (error) => {
|
|
emitStatus(serialState, `Serial Fehler: ${error.message}`);
|
|
});
|
|
|
|
await new Promise((resolve, reject) => {
|
|
serialState.port.open((error) => {
|
|
if (error) {
|
|
reject(error);
|
|
return;
|
|
}
|
|
resolve(true);
|
|
});
|
|
});
|
|
|
|
emitStatus(serialState, "");
|
|
return serialState.port;
|
|
}
|
|
|
|
async function sendSerial(payload) {
|
|
if (!serialState.config.enabled) {
|
|
return false;
|
|
}
|
|
const port = await ensureSerialPortOpen();
|
|
const text = String(payload.text ?? "");
|
|
return new Promise((resolve, reject) => {
|
|
port.write(text, "utf8", (error) => {
|
|
if (error) {
|
|
emitStatus(serialState, `Serial Send Fehler: ${error.message}`);
|
|
reject(error);
|
|
return;
|
|
}
|
|
emitStatus(serialState, "");
|
|
resolve(true);
|
|
});
|
|
});
|
|
}
|
|
|
|
async function listSerialPorts() {
|
|
if (!SerialPort) {
|
|
throw dependencyError("Serial", serialportDependency);
|
|
}
|
|
const ports = await SerialPort.list();
|
|
return ports.map((port) => ({
|
|
path: port.path,
|
|
manufacturer: port.manufacturer || "",
|
|
friendlyName: port.path
|
|
}));
|
|
}
|
|
|
|
async function listNetworkInterfaces() {
|
|
const interfaces = os.networkInterfaces();
|
|
const items = [];
|
|
|
|
Object.entries(interfaces).forEach(([name, entries]) => {
|
|
(entries || []).forEach((entry) => {
|
|
const family = typeof entry.family === "string" ? entry.family : String(entry.family);
|
|
if (family !== "IPv4" || entry.internal || !entry.address) {
|
|
return;
|
|
}
|
|
|
|
items.push({
|
|
id: entry.address,
|
|
name: `${name} - ${entry.address}`
|
|
});
|
|
});
|
|
});
|
|
|
|
items.sort((left, right) => left.name.localeCompare(right.name));
|
|
return items;
|
|
}
|
|
|
|
async function disconnectModbusClient(state) {
|
|
const client = state.client;
|
|
state.client = null;
|
|
if (client?.isOpen) {
|
|
try {
|
|
await client.close();
|
|
} catch (_error) {
|
|
// Best effort close.
|
|
}
|
|
}
|
|
state.connected = false;
|
|
state.signature = "";
|
|
}
|
|
|
|
async function configureModbusTcp(nextConfig) {
|
|
modbusTcpState.config = normalizeModbusTcpConfig(nextConfig);
|
|
await disconnectModbusClient(modbusTcpState);
|
|
if (modbusTcpState.config.enabled && !ModbusRTU) {
|
|
emitStatus(modbusTcpState, dependencyError("Modbus TCP", modbusDependency).message);
|
|
return modbusTcpState.config;
|
|
}
|
|
emitStatus(modbusTcpState, "");
|
|
return modbusTcpState.config;
|
|
}
|
|
|
|
async function configureModbusRtu(nextConfig) {
|
|
modbusRtuState.config = normalizeModbusRtuConfig(nextConfig);
|
|
await disconnectModbusClient(modbusRtuState);
|
|
if (modbusRtuState.config.enabled && !ModbusRTU) {
|
|
emitStatus(modbusRtuState, dependencyError("Modbus RTU", modbusDependency).message);
|
|
return modbusRtuState.config;
|
|
}
|
|
emitStatus(modbusRtuState, "");
|
|
return modbusRtuState.config;
|
|
}
|
|
|
|
async function ensureModbusTcpConnected() {
|
|
if (!ModbusRTU) {
|
|
throw dependencyError("Modbus TCP", modbusDependency);
|
|
}
|
|
if (!modbusTcpState.config.enabled) {
|
|
throw new Error("Modbus TCP deaktiviert");
|
|
}
|
|
const signature = `${modbusTcpState.config.host}:${modbusTcpState.config.port}:${modbusTcpState.config.timeout}`;
|
|
if (modbusTcpState.connected && modbusTcpState.signature === signature && modbusTcpState.client.isOpen) {
|
|
return modbusTcpState.client;
|
|
}
|
|
await disconnectModbusClient(modbusTcpState);
|
|
modbusTcpState.client = new ModbusRTU();
|
|
await modbusTcpState.client.connectTCP(modbusTcpState.config.host, {
|
|
port: modbusTcpState.config.port,
|
|
timeout: modbusTcpState.config.timeout,
|
|
localAddress: modbusTcpState.config.localAddress || undefined
|
|
});
|
|
modbusTcpState.client.setTimeout(modbusTcpState.config.timeout);
|
|
modbusTcpState.connected = true;
|
|
modbusTcpState.signature = signature;
|
|
emitStatus(modbusTcpState, "");
|
|
return modbusTcpState.client;
|
|
}
|
|
|
|
async function ensureModbusRtuConnected() {
|
|
if (!ModbusRTU) {
|
|
throw dependencyError("Modbus RTU", modbusDependency);
|
|
}
|
|
if (!modbusRtuState.config.enabled) {
|
|
throw new Error("Modbus RTU deaktiviert");
|
|
}
|
|
if (!modbusRtuState.config.path) {
|
|
throw new Error("Modbus RTU Port nicht gesetzt");
|
|
}
|
|
const signature = `${modbusRtuState.config.path}:${modbusRtuState.config.baudRate}:${modbusRtuState.config.parity}:${modbusRtuState.config.dataBits}:${modbusRtuState.config.stopBits}`;
|
|
if (modbusRtuState.connected && modbusRtuState.signature === signature && modbusRtuState.client.isOpen) {
|
|
return modbusRtuState.client;
|
|
}
|
|
await disconnectModbusClient(modbusRtuState);
|
|
modbusRtuState.client = new ModbusRTU();
|
|
await modbusRtuState.client.connectRTUBuffered(modbusRtuState.config.path, {
|
|
baudRate: modbusRtuState.config.baudRate,
|
|
parity: modbusRtuState.config.parity,
|
|
dataBits: modbusRtuState.config.dataBits,
|
|
stopBits: modbusRtuState.config.stopBits
|
|
});
|
|
modbusRtuState.client.setTimeout(modbusRtuState.config.timeout);
|
|
modbusRtuState.connected = true;
|
|
modbusRtuState.signature = signature;
|
|
emitStatus(modbusRtuState, "");
|
|
return modbusRtuState.client;
|
|
}
|
|
|
|
async function writeModbus(client, payload) {
|
|
client.setID(Number(payload.unitId) || 1);
|
|
const address = Number(payload.address) || 0;
|
|
const value = Number(payload.value) || 0;
|
|
if (payload.registerType === "coil") {
|
|
await client.writeCoil(address, value >= 1);
|
|
} else {
|
|
await client.writeRegister(address, Math.max(0, Math.min(65535, Math.round(value))));
|
|
}
|
|
}
|
|
|
|
async function sendModbusTcp(payload) {
|
|
const client = await ensureModbusTcpConnected();
|
|
try {
|
|
await writeModbus(client, payload);
|
|
emitStatus(modbusTcpState, "");
|
|
return true;
|
|
} catch (error) {
|
|
emitStatus(modbusTcpState, `Modbus TCP Fehler: ${error.message}`);
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
async function sendModbusRtu(payload) {
|
|
const client = await ensureModbusRtuConnected();
|
|
try {
|
|
await writeModbus(client, payload);
|
|
emitStatus(modbusRtuState, "");
|
|
return true;
|
|
} catch (error) {
|
|
emitStatus(modbusRtuState, `Modbus RTU Fehler: ${error.message}`);
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
function disconnectKnx() {
|
|
return new Promise((resolve) => {
|
|
if (!knxState.connection) {
|
|
knxState.connected = false;
|
|
knxState.connecting = null;
|
|
resolve();
|
|
return;
|
|
}
|
|
|
|
const connection = knxState.connection;
|
|
knxState.connection = null;
|
|
knxState.connected = false;
|
|
knxState.connecting = null;
|
|
try {
|
|
connection.Disconnect(() => resolve());
|
|
} catch (_error) {
|
|
resolve();
|
|
}
|
|
});
|
|
}
|
|
|
|
async function configureKnx(nextConfig) {
|
|
knxState.config = normalizeKnxConfig(nextConfig);
|
|
await disconnectKnx();
|
|
if (knxState.config.enabled && !knx) {
|
|
emitStatus(knxState, dependencyError("KNX", knxDependency).message);
|
|
return knxState.config;
|
|
}
|
|
emitStatus(knxState, "");
|
|
return knxState.config;
|
|
}
|
|
|
|
async function ensureKnxConnection() {
|
|
if (!knx) {
|
|
throw dependencyError("KNX", knxDependency);
|
|
}
|
|
if (!knxState.config.enabled) {
|
|
throw new Error("KNX deaktiviert");
|
|
}
|
|
if (knxState.connection && knxState.connected) {
|
|
return knxState.connection;
|
|
}
|
|
if (knxState.connecting) {
|
|
return knxState.connecting;
|
|
}
|
|
|
|
knxState.connecting = new Promise((resolve, reject) => {
|
|
try {
|
|
const connection = knx.Connection({
|
|
ipAddr: knxState.config.ipAddr,
|
|
ipPort: knxState.config.ipPort,
|
|
interface: knxState.config.interface || undefined,
|
|
physAddr: knxState.config.physAddr,
|
|
forceTunneling: knxState.config.forceTunneling,
|
|
handlers: {
|
|
connected: function () {
|
|
knxState.connection = connection;
|
|
knxState.connected = true;
|
|
knxState.connecting = null;
|
|
emitStatus(knxState, "");
|
|
resolve(connection);
|
|
},
|
|
disconnected: function () {
|
|
knxState.connected = false;
|
|
knxState.connection = null;
|
|
},
|
|
error: function (error) {
|
|
knxState.connected = false;
|
|
knxState.connection = null;
|
|
knxState.connecting = null;
|
|
const message = error?.message || String(error);
|
|
emitStatus(knxState, `KNX Fehler: ${message}`);
|
|
reject(error instanceof Error ? error : new Error(message));
|
|
}
|
|
}
|
|
});
|
|
knxState.connection = connection;
|
|
} catch (error) {
|
|
knxState.connecting = null;
|
|
emitStatus(knxState, `KNX Fehler: ${error.message}`);
|
|
reject(error);
|
|
}
|
|
});
|
|
|
|
return knxState.connecting;
|
|
}
|
|
|
|
async function sendKnx(payload) {
|
|
const connection = await ensureKnxConnection();
|
|
const dpt = String(payload.dpt || "DPT5.001");
|
|
let value = payload.value;
|
|
if (dpt.startsWith("DPT1")) {
|
|
value = Number(value) >= 1;
|
|
} else if (dpt.startsWith("DPT16")) {
|
|
value = String(value ?? "");
|
|
} else {
|
|
value = Number(value) || 0;
|
|
}
|
|
|
|
return new Promise((resolve, reject) => {
|
|
try {
|
|
connection.write(String(payload.groupAddress || "1/1/1"), value, dpt, (error) => {
|
|
if (error) {
|
|
emitStatus(knxState, `KNX Send Fehler: ${error.message}`);
|
|
reject(error);
|
|
return;
|
|
}
|
|
emitStatus(knxState, "");
|
|
resolve(true);
|
|
});
|
|
} catch (error) {
|
|
emitStatus(knxState, `KNX Send Fehler: ${error.message}`);
|
|
reject(error);
|
|
}
|
|
});
|
|
}
|
|
|
|
configureMqtt(mqttState.config);
|
|
|
|
contextBridge.exposeInMainWorld("time4midi", {
|
|
project: {
|
|
save: (payload) => ipcRenderer.invoke("project:save", payload),
|
|
load: () => ipcRenderer.invoke("project:load")
|
|
},
|
|
audio: {
|
|
pickFile: () => ipcRenderer.invoke("audio:pickFile"),
|
|
readFile: async (filePath) => {
|
|
const buffer = await fs.readFile(filePath);
|
|
return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
|
|
},
|
|
fileUrl: (filePath) => pathToFileURL(filePath).href
|
|
},
|
|
network: {
|
|
listInterfaces: () => listNetworkInterfaces()
|
|
},
|
|
artnet: {
|
|
configure: (config) => configureArtNet(config),
|
|
sendDmx: (payload) => sendArtNetDmx(payload),
|
|
onTimecode: (handler) => {
|
|
artnet.listeners.add(handler);
|
|
ensureArtNetListener();
|
|
return () => {
|
|
artnet.listeners.delete(handler);
|
|
};
|
|
},
|
|
onStatus: (handler) => addStatusApi(artnet, handler)
|
|
},
|
|
sacn: {
|
|
configure: (config) => configureSacn(config),
|
|
sendDmx: (payload) => sendSacnDmx(payload),
|
|
onStatus: (handler) => addStatusApi(sacn, handler)
|
|
},
|
|
osc: {
|
|
configure: (config) => configureOsc(config),
|
|
send: (payload) => sendOsc(payload),
|
|
onStatus: (handler) => addStatusApi(osc, handler)
|
|
},
|
|
mqtt: {
|
|
configure: (config) => configureMqtt(config),
|
|
publish: (payload) => publishMqtt(payload),
|
|
onStatus: (handler) => addStatusApi(mqttState, handler)
|
|
},
|
|
serial: {
|
|
configure: (config) => configureSerial(config),
|
|
send: (payload) => sendSerial(payload),
|
|
listPorts: () => listSerialPorts(),
|
|
onStatus: (handler) => addStatusApi(serialState, handler)
|
|
},
|
|
modbusTcp: {
|
|
configure: (config) => configureModbusTcp(config),
|
|
send: (payload) => sendModbusTcp(payload),
|
|
onStatus: (handler) => addStatusApi(modbusTcpState, handler)
|
|
},
|
|
modbusRtu: {
|
|
configure: (config) => configureModbusRtu(config),
|
|
send: (payload) => sendModbusRtu(payload),
|
|
onStatus: (handler) => addStatusApi(modbusRtuState, handler)
|
|
},
|
|
knx: {
|
|
configure: (config) => configureKnx(config),
|
|
send: (payload) => sendKnx(payload),
|
|
onStatus: (handler) => addStatusApi(knxState, handler)
|
|
}
|
|
});
|