verschiedene Skripte

helfi9999

Hallo zusammen,
habe mal bei mir aufgeräumt und habe eine ganze Menge an Skripten die ich von hier habe und stellenweise auch umgebaut habe die ich jetzt gerne mit euch teilen möchte:

z.B.
Musikstatus je Raum mit Alexa und/oder Sonos mit States Erstellung.Voraussetzung ist der Alexa Adapter und der Sonos Adapter:

Ihr müsst nur die Geräte im Skript ändern.


/*************************************************
* Musikstatus je Raum
* mit State-Erstellung + Provider-Erkennung
*************************************************/

const rooms = [
   {
       name: "Wohnzimmer",
       target: "0_userdata.0.Status_Musikboxen.Wohnzimmer_Status",
       alexaState: "Deine Alexa.Player.currentState",
       alexaProvider: "Deine Alexa.Player.providerName",
       sonosState: "sonos.0.root.192_168_178_XXX.state_simple",
       sonosType: "sonos.0.root.192_168_178_XXX.current_type",
       delayMs: 0,
       config: { alexaDirectProvider: false, sonosMap: {0:"Musik von Platte",1:"TuneIn-Liveradio",2:"Fernseher"} }
   },
   {
       name: "Esszimmer",
       target: "0_userdata.0.Status_Musikboxen.Esszimmer_Status",
       alexaState: "Deine Alexa.Player.currentState",
       alexaProvider: "Deine Alexa.Player.providerName",
       sonosState: "sonos.0.root.192_168_178_XXX.state_simple",
       sonosType: "sonos.0.root.192_168_178_XXX.current_type",
       delayMs: 0,
       config: { alexaDirectProvider: false, sonosMap: {0:"Musik von Platte",1:"TuneIn-Liveradio"} }
   },
   {
       name: "Küche",
       target: "0_userdata.0.Status_Musikboxen.Küche_Status",
       alexaState: "Deine Alexa.Player.currentState",
       alexaProvider: "Deine Alexa.Player.providerName",
       sonosState: "sonos.0.root.192_168_178_XXX.state_simple",
       sonosType: "sonos.0.root.192_168_178_XXX.current_type",
       delayMs: 0,
       config: { alexaDirectProvider: false, sonosMap: {0:"Musik von Platte",1:"TuneIn-Liveradio"} }
   },
   {
       name: "Garten",
       target: "0_userdata.0.Status_Musikboxen.Garten_Status",
       alexaState: "Deine Alexa.Player.currentState",
       alexaProvider: "Deine Alexa.Player.providerName",
       delayMs: 2000,
       config: { alexaDirectProvider: true }
   },
   {
       name: "Schlafzimmer",
       target: "0_userdata.0.Status_Musikboxen.Schlafzimmer_Status",
       alexaState: "Deine Alexa.Player.currentState",
       alexaProvider: "Deine Alexa.Player.providerName",
       delayMs: 2000,
       config: { alexaDirectProvider: true }
   },
   {
       name: "Spielzimmer",
       target: "0_userdata.0.Status_Musikboxen.Spielzimmer_Status",
       alexaState: "Deine Alexa.Player.currentState",
       alexaProvider: "Deine Alexa.Player.providerName",
       delayMs: 0,
       config: { alexaDirectProvider: true }
   },
   {
       name: "Kinderzimmer",
       target: "0_userdata.0.Status_Musikboxen.Kinderzimmer_Status",
       alexaState: "Deine Alexa.Player.currentState",
       alexaProvider: "Deine Alexa.Player.providerName",
       delayMs: 2000,
       config: { alexaDirectProvider: true }
   },
   {
       name: "Gäste WC",
       target: "0_userdata.0.Status_Musikboxen.Gaeste_WC",
       alexaState: "Deine Alexa.Player.currentState",
       alexaProvider: "Deine Alexa.Player.providerName",
       delayMs: 0,
       config: { alexaDirectProvider: true }
   },
   {
       name: "Badezimmer",
       target: "0_userdata.0.Status_Musikboxen.Badezimmer_Status",
       alexaState: "Deine Alexa.Player.currentState",
       alexaProvider: "Deine Alexa.Player.providerName",
       sonosState: "sonos.0.root.192_168_178_XXX.state_simple",
       sonosType: "sonos.0.root.192_168_178_XXX.current_type",
       delayMs: 0,
       config: { alexaDirectProvider: false, sonosMap: {0:"Musik von Platte",1:"TuneIn-Liveradio"} }
   },
   {
       name: "Hobbyraum",
       target: "0_userdata.0.Status_Musikboxen.Hobbyraum_Status",
       alexaState: "Deine Alexa.Player.currentState",
       alexaProvider: "Deine Alexa.Player.providerName",
       sonosState: "sonos.0.root.192_168_178_XXX.state_simple",
       sonosType: "sonos.0.root.192_168_178_XXX.current_type",
       delayMs: 0,
       config: { alexaDirectProvider: false, sonosMap: {0:"Musik von Platte",1:"TuneIn-Liveradio"} }
   }
];

/*********************** STATES ERSTELLEN ***********************/

function createTargetState(room) {
   createState(room.target, "nichts", {
       name: `Musikstatus ${room.name}`,
       type: "string",
       role: "text",
       read: true,
       write: true
   });
}

/*********************** LOGIK ***********************/

function readVal(id, def = null) {
   if (!id) return def;
   const s = getState(id);
   return s ? s.val : def;
}

function normalizeProvider(p) {
   if (!p) return "";

   const raw = String(p).trim();
   const t = raw.toLowerCase();

   if (t.includes("amazon")) return "Amazon Music";
   if (t.includes("spotify")) return "Spotify";
   if (t.includes("tunein") || t.includes("radio")) return "TuneIn-Liveradio";
   if (t.includes("audible")) return "Audible";
   if (t.includes("apple")) return "Apple Music";
   if (t.includes("deezer")) return "Deezer";
   if (t.includes("youtube")) return "YouTube";
   if (t.includes("podcast")) return "Podcast";
   if (t.includes("bluetooth") || t.includes("aux") || t.includes("line")) return "Externe Quelle";

   return raw;
}

function writeStatus(room, val) {
   if (room.delayMs > 0) {
       setStateDelayed(room.target, val, true, room.delayMs, true);
   } else {
       setState(room.target, val, true);
   }
}

function evalRoom(room) {
   const alexaPlaying = readVal(room.alexaState, false) === true;
   const alexaProvider = normalizeProvider(readVal(room.alexaProvider, ""));
   const sonosPlaying = readVal(room.sonosState, false) === true;
   const sonosType = readVal(room.sonosType, null);

   if (room.config.alexaDirectProvider) {
       if (alexaPlaying) {
           writeStatus(room, alexaProvider || "Andere Quelle");
           log(`+++ ${room.name}: ${alexaProvider || "Andere Quelle"} +++`, "debug");
       } else {
           writeStatus(room, "nichts");
       }
       return;
   }

   if (alexaPlaying && alexaProvider) {
       writeStatus(room, alexaProvider);
       return;
   }

   if (
       sonosPlaying &&
       room.config.sonosMap &&
       room.config.sonosMap[sonosType] !== undefined
   ) {
       writeStatus(room, room.config.sonosMap[sonosType]);
       return;
   }

   writeStatus(room, "nichts");
}

function initRoom(room) {
   createTargetState(room);

   const ids = [];

   if (room.alexaState) ids.push(room.alexaState);
   if (room.alexaProvider) ids.push(room.alexaProvider);
   if (room.sonosState) ids.push(room.sonosState);
   if (room.sonosType) ids.push(room.sonosType);

   if (ids.length === 0) {
       log(`Keine Trigger für ${room.name} konfiguriert`, "warn");
       return;
   }

   on({ id: ids, change: "ne" }, () => evalRoom(room));

   setTimeout(() => {
       evalRoom(room);
   }, 1000);
}

/*********************** START ***********************/

rooms.forEach(initRoom);

Lautstärken Reset in Verbindung mit dem Skript Musikstatus
Funktionen:

- Reagiert auf Statusänderung eines Raums
- Prüft auf Zielstatus "nichts"
- Setzt Lautstärke definierter Geräte nach optionaler Verzögerung
- Verhindert Mehrfach-Timer pro Raum
- Optionales Debug-Logging
- Alexa notificationVolume wird explizit über notificationId gesetzt
- Sonderfall Kinderzimmer: nur notificationVolume, kein Player.volume

/**
 * Echo Stati / Lautstärke-Reset
 *
 * Funktionen:
 * - Reagiert auf Statusänderung eines Raums
 * - Prüft auf Zielstatus "nichts"
 * - Setzt Lautstärke definierter Geräte nach optionaler Verzögerung
 * - Verhindert Mehrfach-Timer pro Raum
 * - Optionales Debug-Logging
 * - Alexa notificationVolume wird explizit über notificationId gesetzt
 * - Sonderfall Kinderzimmer: nur notificationVolume, kein Player.volume
 */

const CONFIG = {
    targetStatus: 'nichts',
    defaultDelayMs: 5000,
    debug: true,
    logPrefix: '[Musikboxen]',
    minNotificationVolume: 0,
    maxNotificationVolume: 100,
    defaultNotificationOffset: 5
};

const rooms = [
    {
        name: 'Küche',
        enabled: true,
        statusId: '0_userdata.0.Status_Musikboxen.Küche_Status',
        delayMs: 0,
        trigger: 'ne',
        devices: [
            {
                id: 'alexa2.0.Echo-Devices.661b5e9aa0b24161a4ec52b340173846.Player.volume',
                notificationId: 'alexa2.0.Echo-Devices.661b5e9aa0b24161a4ec52b340173846.Preferences.notificationVolume',
                volume: 10,
                notificationOffset: 5
            },
            {
                id: 'alexa2.0.Echo-Devices.4879f7942cdb42d596f4e24aac81e908.Player.volume',
                notificationId: 'alexa2.0.Echo-Devices.661b5e9aa0b24161a4ec52b340173846.Preferences.notificationVolume',
                volume: 10,
                notificationOffset: 5
            },
            {
                id: 'sonos.0.root.192_168_178_18.volume',
                volume: 10
            }
        ]
    },
    {
        name: 'Wohnzimmer',
        enabled: true,
        statusId: '0_userdata.0.Status_Musikboxen.Wohnzimmer_Status',
        delayMs: CONFIG.defaultDelayMs,
        trigger: 'any',
        devices: [
            {
                id: 'alexa2.0.Echo-Devices.025b455db7bb4720ad941b7139bcc805.Player.volume',
                notificationId: 'alexa2.0.Echo-Devices.d5794400dafd4c2cb0c8889fc15f0653.Preferences.notificationVolume',
                volume: 10,
                notificationOffset: 5
            },
            {
                id: 'alexa2.0.Echo-Devices.d5794400dafd4c2cb0c8889fc15f0653.Player.volume',
                notificationId: 'alexa2.0.Echo-Devices.d5794400dafd4c2cb0c8889fc15f0653.Preferences.notificationVolume',
                volume: 10,
                notificationOffset: 5
            },
            {
                id: 'sonos.0.root.192_168_178_21.volume',
                volume: 10
            }
        ]
    },
    {
        name: 'Esszimmer',
        enabled: true,
        statusId: '0_userdata.0.Status_Musikboxen.Esszimmer_Status',
        delayMs: CONFIG.defaultDelayMs,
        trigger: 'any',
        devices: [
            {
                id: 'alexa2.0.Echo-Devices.084e4de76a484be18aeda245e8f3f4d4.Player.volume',
                notificationId: 'alexa2.0.Echo-Devices.c31ec0fc26584e078ca0555aecfc9188.Preferences.notificationVolume',
                volume: 10,
                notificationOffset: 5
            },
            {
                id: 'alexa2.0.Echo-Devices.c31ec0fc26584e078ca0555aecfc9188.Player.volume',
                notificationId: 'alexa2.0.Echo-Devices.c31ec0fc26584e078ca0555aecfc9188.Preferences.notificationVolume',
                volume: 10,
                notificationOffset: 5
            },
            {
                id: 'sonos.0.root.192_168_178_20.volume',
                volume: 10
            }
        ]
    },
    {
        name: 'Schlafzimmer',
        enabled: true,
        statusId: '0_userdata.0.Status_Musikboxen.Schlafzimmer_Status',
        delayMs: CONFIG.defaultDelayMs,
        trigger: 'ne',
        devices: [
            {
                id: 'alexa2.0.Echo-Devices.G091MK0614730BNS.Player.volume',
                notificationId: 'alexa2.0.Echo-Devices.G091MK0614730BNS.Preferences.notificationVolume',
                volume: 18,
                notificationOffset: 12
            }
        ]
    },
    {
        name: 'Hobbyraum',
        enabled: true,
        statusId: '0_userdata.0.Status_Musikboxen.Hobbyraum_Status',
        delayMs: CONFIG.defaultDelayMs,
        trigger: 'ne',
        devices: [
            {
                id: 'alexa2.0.Echo-Devices.d3127dcdc8bc4158807fcab2fcfe7fba.Player.volume',
                notificationId: 'alexa2.0.Echo-Devices.c9d487971e914e939baad79585dd7b2e.Preferences.notificationVolume',
                volume: 10,
                notificationOffset: 5
            }
        ]
    },
    {
        name: 'Gäste WC',
        enabled: true,
        statusId: '0_userdata.0.Status_Musikboxen.Gaeste_WC',
        delayMs: CONFIG.defaultDelayMs,
        trigger: 'ne',
        devices: [
            {
                id: 'alexa2.0.Echo-Devices.G090LF10718513KQ.Player.volume',
                notificationId: 'alexa2.0.Echo-Devices.G090LF10718513KQ.Preferences.notificationVolume',
                volume: 15,
                notificationOffset: 8
            }
        ]
    },
    {
        name: 'Badezimmer',
        enabled: true,
        statusId: '0_userdata.0.Status_Musikboxen.Badezimmer_Status',
        delayMs: CONFIG.defaultDelayMs,
        trigger: 'any',
        devices: [
            {
                id: 'alexa2.0.Echo-Devices.828b54738e2a44a29d9331868a046c38.Player.volume',
                notificationId: 'alexa2.0.Echo-Devices.eba89b7180384792a24f92847baea082.Preferences.notificationVolume',
                volume: 10,
                notificationOffset: 5
            },
            {
                id: 'alexa2.0.Echo-Devices.eba89b7180384792a24f92847baea082.Player.volume',
                notificationId: 'alexa2.0.Echo-Devices.eba89b7180384792a24f92847baea082.Preferences.notificationVolume',
                volume: 10,
                notificationOffset: 5
            },
            {
                id: 'sonos.0.root.192_168_178_17.volume',
                volume: 10
            }
        ]
    },
    {
        name: 'Spielzimmer',
        enabled: true,
        statusId: '0_userdata.0.Status_Musikboxen.Spielzimmer_Status',
        delayMs: CONFIG.defaultDelayMs,
        trigger: 'any',
        devices: [
            {
                id: 'alexa2.0.Echo-Devices.G2A0P3077407031K.Player.volume',
                notificationId: 'alexa2.0.Echo-Devices.G2A0P3077407031K.Preferences.notificationVolume',
                volume: 25,
                notificationOffset: 15
            }
        ]
    },
    {
        name: 'Kinderzimmer',
        enabled: true,
        statusId: '0_userdata.0.Status_Musikboxen.Kinderzimmer_Status',
        delayMs: CONFIG.defaultDelayMs,
        trigger: 'any',
        devices: [
            {
                notificationId: 'alexa2.0.Echo-Devices.G0911B05926204Q7.Preferences.notificationVolume',
                volume: 11,
                notificationOffset: 6,
                notificationOnly: true
            }
        ]
    },
    {
        name: 'Garten',
        enabled: true,
        statusId: '0_userdata.0.Status_Musikboxen.Garten_Status',
        delayMs: CONFIG.defaultDelayMs,
        trigger: 'any',
        devices: [
            {
                id: 'alexa2.0.Echo-Devices.G091AA08052203UL.Player.volume',
                notificationId: 'alexa2.0.Echo-Devices.G091AA08052203UL.Preferences.notificationVolume',
                volume: 15,
                notificationOffset: 8
            }
        ]
    }
];

const activeTimers = {};

function logInfo(msg) {
    log(`${CONFIG.logPrefix} ${msg}`, 'info');
}

function logDebug(msg) {
    if (CONFIG.debug) {
        log(`${CONFIG.logPrefix} ${msg}`, 'debug');
    }
}

function logWarn(msg) {
    log(`${CONFIG.logPrefix} ${msg}`, 'warn');
}

function logError(msg) {
    log(`${CONFIG.logPrefix} ${msg}`, 'error');
}

function isTargetStatus(value) {
    if (value === null || value === undefined) return false;
    return String(value).trim() === CONFIG.targetStatus;
}

function isValidVolume(volume) {
    return typeof volume === 'number' && isFinite(volume) && volume >= 0 && volume <= 100;
}

function stateExists(id) {
    try {
        return !!getObject(id);
    } catch (e) {
        return false;
    }
}

function clamp(value, min, max) {
    return Math.max(min, Math.min(max, value));
}

function getNotificationVolume(volume, notificationOffset) {
    const offset = typeof notificationOffset === 'number'
        ? notificationOffset
        : CONFIG.defaultNotificationOffset;

    return clamp(
        volume - offset,
        CONFIG.minNotificationVolume,
        CONFIG.maxNotificationVolume
    );
}

function clearRoomTimer(roomName) {
    if (activeTimers[roomName]) {
        clearTimeout(activeTimers[roomName]);
        activeTimers[roomName] = null;
        logDebug(`${roomName}: vorhandener Timer gelöscht`);
    }
}

function setDeviceVolume(device, roomName) {
    if (!device) {
        logWarn(`${roomName}: ungültiges Gerät übersprungen`);
        return;
    }

    if (!isValidVolume(device.volume)) {
        logWarn(`${roomName}: ungültige Lautstärke ${device.volume}`);
        return;
    }

    if (!device.notificationOnly) {
        if (!device.id) {
            logWarn(`${roomName}: Gerät ohne ID übersprungen`);
            return;
        }

        if (!stateExists(device.id)) {
            logWarn(`${roomName}: Datenpunkt nicht gefunden: ${device.id}`);
            return;
        }

        try {
            setState(device.id, device.volume);
            logInfo(`${roomName}: Volume ${device.volume} gesetzt -> ${device.id}`);
        } catch (e) {
            logError(`${roomName}: Fehler beim Setzen von ${device.id}: ${e}`);
            return;
        }
    }

    if (device.notificationId) {
        if (!stateExists(device.notificationId)) {
            logWarn(`${roomName}: notificationVolume-Datenpunkt nicht gefunden: ${device.notificationId}`);
            return;
        }

        const notificationVolume = getNotificationVolume(device.volume, device.notificationOffset);

        try {
            setState(device.notificationId, notificationVolume);
            logInfo(`${roomName}: notificationVolume ${notificationVolume} gesetzt -> ${device.notificationId}`);
        } catch (e) {
            logError(`${roomName}: Fehler beim Setzen von ${device.notificationId}: ${e}`);
        }
    }
}

function resetRoomVolume(room) {
    if (!room || !Array.isArray(room.devices) || room.devices.length === 0) {
        logWarn(`${room && room.name ? room.name : 'Unbekannter Raum'}: keine Geräte konfiguriert`);
        activeTimers[room && room.name ? room.name : 'unknown'] = null;
        return;
    }

    room.devices.forEach(device => setDeviceVolume(device, room.name));
    activeTimers[room.name] = null;
}

function scheduleReset(room) {
    clearRoomTimer(room.name);

    const delayMs = typeof room.delayMs === 'number' && room.delayMs >= 0
        ? room.delayMs
        : CONFIG.defaultDelayMs;

    if (delayMs === 0) {
        logDebug(`${room.name}: sofortiger Reset`);
        resetRoomVolume(room);
        return;
    }

    logDebug(`${room.name}: Reset in ${delayMs} ms geplant`);

    activeTimers[room.name] = setTimeout(() => {
        activeTimers[room.name] = null;
        resetRoomVolume(room);
    }, delayMs);
}

function registerRoom(room) {
    if (!room || !room.name || !room.statusId) {
        logWarn('Ungültige Raum-Konfiguration übersprungen');
        return;
    }

    if (!room.enabled) {
        logDebug(`${room.name}: deaktiviert`);
        return;
    }

    if (!stateExists(room.statusId)) {
        logWarn(`${room.name}: Status-Datenpunkt nicht gefunden: ${room.statusId}`);
        return;
    }

    const trigger = room.trigger || 'ne';

    on({ id: room.statusId, change: trigger }, obj => {
        try {
            if (!obj || !obj.state) {
                logDebug(`${room.name}: Event ohne state erhalten`);
                return;
            }

            const newValue = obj.state.val;
            const oldValue = obj.oldState ? obj.oldState.val : undefined;
            const ack = obj.state.ack;

            logDebug(`${room.name}: Event | alt="${oldValue}" neu="${newValue}" ack=${ack}`);

            if (!isTargetStatus(newValue)) {
                logDebug(`${room.name}: Status ist nicht "${CONFIG.targetStatus}", kein Reset`);
                return;
            }

            scheduleReset(room);
        } catch (e) {
            logError(`${room.name}: Fehler im Event-Handler: ${e}`);
        }
    });

    logInfo(`${room.name}: Trigger registriert (${trigger}) auf ${room.statusId}`);
}

rooms.forEach(registerRoom);
logInfo('Lautstärke-Reset-Skript mit expliziten notificationIds gestartet');

es werden noch weitere folgen

Community Forum

NEWS

verschiedene Skripte

Support us

545

32.8k

82.8k

1.3m