Initial commit

2026-06-16 11:00:24 +02:00
commit bc3a61462a
11 changed files with 9284 additions and 0 deletions
@@ -0,0 +1,941 @@
+const { contextBridge, ipcRenderer } = require("electron");
+const crypto = require("node:crypto");
+const dgram = require("node:dgram");
+const mqtt = require("mqtt");
+const { SerialPort } = require("serialport");
+const ModbusRTU = require("modbus-serial");
+const knx = require("knx");
+
+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 addStatusApi(target, handler) {
+  target.statusListeners.add(handler);
+  handler({
+    ok: !target.lastError,
+    error: target.lastError
+  });
+  return () => {
+    target.statusListeners.delete(handler);
+  };
+}
+
+const artnet = {
+  ...createStatusEmitter(),
+  sendSocket: dgram.createSocket("udp4"),
+  listenSocket: null,
+  listeners: new Set(),
+  config: {
+    enabled: true,
+    host: "255.255.255.255",
+    port: ARTNET_PORT,
+    broadcast: true,
+    timecodeListenPort: ARTNET_PORT
+  },
+  sequence: 1
+};
+
+const sacn = {
+  ...createStatusEmitter(),
+  socket: dgram.createSocket("udp4"),
+  config: {
+    enabled: false,
+    host: "",
+    port: SACN_PORT,
+    multicast: true,
+    sourceName: "Time4Midi"
+  },
+  sequence: 1,
+  cid: crypto.randomBytes(16)
+};
+
+const osc = {
+  ...createStatusEmitter(),
+  socket: dgram.createSocket("udp4"),
+  config: {
+    enabled: false,
+    host: "127.0.0.1",
+    port: 8000
+  }
+};
+
+const mqttState = {
+  ...createStatusEmitter(),
+  client: null,
+  connected: false,
+  config: {
+    enabled: false,
+    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: new ModbusRTU(),
+  connected: false,
+  signature: "",
+  config: {
+    enabled: false,
+    host: "127.0.0.1",
+    port: 502,
+    timeout: 1000
+  }
+};
+
+const modbusRtuState = {
+  ...createStatusEmitter(),
+  client: new ModbusRTU(),
+  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,
+    ipAddr: "224.0.23.12",
+    ipPort: KNX_PORT,
+    physAddr: "15.15.15",
+    forceTunneling: false
+  }
+};
+
+function normalizeArtNetConfig(nextConfig = {}) {
+  return {
+    enabled: nextConfig.enabled !== false,
+    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),
+    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),
+    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),
+    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),
+    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),
+    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 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 = dgram.createSocket("udp4");
+  artnet.listenSocket.on("error", (error) => {
+    emitStatus(artnet, `Art-Net Listen Fehler: ${error.message}`);
+  });
+  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 {
+    artnet.listenSocket.bind(artnet.config.timecodeListenPort);
+  } catch (error) {
+    emitStatus(artnet, `Art-Net Listen Fehler: ${error.message}`);
+  }
+}
+
+function configureArtNet(nextConfig) {
+  const previousPort = artnet.config.timecodeListenPort;
+  artnet.config = normalizeArtNetConfig(nextConfig);
+
+  try {
+    artnet.sendSocket.setBroadcast(artnet.config.broadcast);
+  } catch (error) {
+    emitStatus(artnet, `Art-Net Konfig Fehler: ${error.message}`);
+  }
+
+  if (!artnet.config.enabled) {
+    closeArtNetListener();
+    emitStatus(artnet, "");
+    return artnet.config;
+  }
+
+  if (previousPort !== artnet.config.timecodeListenPort) {
+    closeArtNetListener();
+  }
+  if (artnet.listeners.size > 0) {
+    ensureArtNetListener();
+  }
+  return artnet.config;
+}
+
+function sendArtNetDmx(payload) {
+  if (!artnet.config.enabled) {
+    return Promise.resolve(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;
+
+  return new Promise((resolve, reject) => {
+    artnet.sendSocket.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) {
+  osc.config = normalizeOscConfig(nextConfig);
+  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 };
+}
+
+function sendOsc(payload) {
+  if (!osc.config.enabled) {
+    return Promise.resolve(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
+  ]);
+  return new Promise((resolve, reject) => {
+    osc.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) {
+  sacn.config = normalizeSacnConfig(nextConfig);
+  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);
+}
+
+function sendSacnDmx(payload) {
+  if (!sacn.config.enabled) {
+    return Promise.resolve(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);
+
+  return new Promise((resolve, reject) => {
+    sacn.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;
+  }
+
+  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;
+
+  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();
+  emitStatus(serialState, "");
+  return serialState.config;
+}
+
+async function ensureSerialPortOpen() {
+  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() {
+  const ports = await SerialPort.list();
+  return ports.map((port) => ({
+    path: port.path,
+    manufacturer: port.manufacturer || "",
+    friendlyName: port.path
+  }));
+}
+
+async function disconnectModbusClient(state) {
+  if (state.client?.isOpen) {
+    try {
+      await state.client.close();
+    } catch (_error) {
+      // Best effort close.
+    }
+  }
+  state.connected = false;
+  state.signature = "";
+}
+
+async function configureModbusTcp(nextConfig) {
+  modbusTcpState.config = normalizeModbusTcpConfig(nextConfig);
+  await disconnectModbusClient(modbusTcpState);
+  emitStatus(modbusTcpState, "");
+  return modbusTcpState.config;
+}
+
+async function configureModbusRtu(nextConfig) {
+  modbusRtuState.config = normalizeModbusRtuConfig(nextConfig);
+  await disconnectModbusClient(modbusRtuState);
+  emitStatus(modbusRtuState, "");
+  return modbusRtuState.config;
+}
+
+async function ensureModbusTcpConnected() {
+  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);
+  await modbusTcpState.client.connectTCP(modbusTcpState.config.host, {
+    port: modbusTcpState.config.port,
+    timeout: modbusTcpState.config.timeout
+  });
+  modbusTcpState.client.setTimeout(modbusTcpState.config.timeout);
+  modbusTcpState.connected = true;
+  modbusTcpState.signature = signature;
+  emitStatus(modbusTcpState, "");
+  return modbusTcpState.client;
+}
+
+async function ensureModbusRtuConnected() {
+  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);
+  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();
+  emitStatus(knxState, "");
+  return knxState.config;
+}
+
+async function ensureKnxConnection() {
+  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,
+        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);
+    }
+  });
+}
+
+artnet.sendSocket.on("error", (error) => {
+  emitStatus(artnet, `Art-Net Socket Fehler: ${error.message}`);
+});
+
+osc.socket.on("error", (error) => {
+  emitStatus(osc, `OSC Socket Fehler: ${error.message}`);
+});
+
+sacn.socket.on("error", (error) => {
+  emitStatus(sacn, `sACN Socket Fehler: ${error.message}`);
+});
+
+configureMqtt(mqttState.config);
+
+contextBridge.exposeInMainWorld("time4midi", {
+  project: {
+    save: (payload) => ipcRenderer.invoke("project:save", payload),
+    load: () => ipcRenderer.invoke("project:load")
+  },
+  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)
+  }
+});