Alternativ kann man das folgende Homey Script verwenden. Dieses stellt deutlich mehr Informationen zur Verfügung als nur die Geräteanzahl:
// Set any of these from `false;` to `true;` to see the corresponding Name(s) or Node ID('s) added to the list
const showStorage = false; // Show storage status (Very slow!, is enabled for Homey Pro (early 2023))
const showUpdateableApps = true; // Names of Apps that can be updated
const showDisabledApps = true; // Names of Apps that are disabled or crashed
const showStableApps = false; // Names of Stable channel Apps
const showTestApps = false; // Names of Test channel Apps
const showDevApps = false; // Names of Apps that are installed via CLI or Community Appstore
const showSDKv2Apps = false; // Names of Apps that are on SDKv2
const showSDKv3Apps = false; // Names of Apps that are on SDKv3
const showZones = false; // Names of Zones
const showLogicBoolean = false; // Names and ID of boolean (yes/no) variables
const showLogicNumber = false; // Names and ID of number variables
const showLogicString = false; // Names and ID of string (text) variables
const showDisabledFlows = false; // Names of Flows that are disabled
const showBrokenFlows = false; // Names of Flows that are broken
const showDisabledAdvancedFlows = false; // Names of Advanced Flows that are disabled
const showBrokenAdvancedFlows = false; // Names of Advanced Flows that are broken
const showImages = false; // URLs of all your images (HP 2023+ only)
const showMoods = false; // Names of all Moods (HP 2023+ only)
const showUnavailableDevices = false; // Names of devices that are marked unavailable
const showZwaveDevices = false; // Names and Node ID of all Z-Wave devices
const showZwaveRouterDevices = false; // Names and Node ID of Z-Wave router devices
const showZwaveUnsecureDevices = false; // Names and Node ID of unsecure Z-Wave devices
const showZwaveSecureS0Devices = false; // Names and Node ID of secure (S0) Z-Wave devices
const showZwaveSecureS2AuthenticatedDevices = false; // Names and Node ID of secure (S2 Authenticated) Z-Wave devices
const showZwaveSecureS2UnauthenticatedDevices = false; // Names and Node ID of secure (S2 Unauthenticated) Z-Wave devices
const showZwaveBatteryDevices = false; // Names and Node ID of Z-Wave battery devices
const showZwaveUnreachableNodes = false; // Node ID's of unreachable (flagged) devices
const showZwaveUnknownNodes = false; // Node ID's of unknown nodes
const showZigbeeNodes = false; // Names of all ZigBee devices
const showZigbeeRouter = false; // Names of ZigBee: router devices
const showZigbeeEndDevice = false; // Names of ZigBee: end device devices
const showZigbeeLastSeen = false; // Show additional: the last seen time and date (HP 2023+ only)
const showVirtualDevices = false; // Names of all Virtual devices
const showIRDevices = false; // Names of all InfraRed devices
// ================= Don't edit anything below here =================
log('--------------- Homey Pro Overview v1.17 --------------');
await Homey.system.getSystemName()
.then(result => log('Homey name:', result))
.catch(() => log('Failed: Getting Homey name'));
let homeyPlatformVersion, homeyVersion, timezone;
await Homey.system.getInfo()
.then(result => {
log('Homey version:', homeyVersion = result.homeyVersion);
log('Homey model:', result.homeyModelName, '(' + result.cpus.length + ' core(s))');
homeyPlatformVersion = result.homeyPlatformVersion || 1;
timezone = result.timezone;
const d = Math.floor(result.uptime / 86400);
const h = Math.floor((result.uptime % 86400) / 3600);
const m = Math.floor((result.uptime % 3600) / 60);
const s = Math.floor(result.uptime % 60);
let uptimeHuman = '';
if (d > 0) uptimeHuman += d + ' day' + (d > 1 ? 's, ' : ', ');
uptimeHuman += h + ' hour' + (h > 1 ? 's, ' : ', ');
uptimeHuman += m + ' minute' + (m > 1 ? 's, ' : ', ');
uptimeHuman += s + ' second' + (s > 1 ? 's' : '');
log('Uptime:', result.uptime, '(' + uptimeHuman + ')');
if (homeyPlatformVersion === 2) {
log('WiFi:', (result.wifiConnected) ? 'Connected' : 'Not connected');
log('Ethernet:', (result.ethernetConnected) ? 'Connected' : 'Not connected');
log('Throttled:', (result.videoCoreThrottleOccured) ? 'Yes' : 'No', '(Currently:', (result.videoCoreThrottleCurrently) ? 'Yes)' : 'No)');
log('Under voltage:', (result.videoCoreUndervoltageOccured) ? 'Yes' : 'No', '(Currently:', (result.videoCoreUnderVoltageCurrently) ? 'Yes)' : 'No)');
}
})
.catch(() => log('Failed: Getting Homey\'s statistics'));
await Homey.updates.getUpdates()
.then(result => {
if(result.length > 0) {
log('Update available:', result[0].version);
} else {
log('Update available: No');
}
})
.catch(() => log('Failed: Getting updates'));
if (showStorage || homeyPlatformVersion === 2) {
await Homey.system.getStorageInfo()
.then(result => {
let sizeFree = result.free + 'B'
if (result.free >= 1000000000) {
sizeFree = (result.free / 1000000000).toFixed(2) + ' GB';
} else if (result.free >= 1000000) {
sizeFree = (result.free / 1000000).toFixed(2) + ' MB';
}
log('Storage:', (result.total / 1000000000).toFixed(2), 'GB (' + sizeFree + ' free)');
})
.catch(() => log('Failed: Getting storage information'));
}
log('\r\n------------------ Main ---------------------');
await Homey.users.getUsers()
.then(result => {
let owner = 0, manager = 0, user = 0, guest = 0;
Object.keys(result).forEach(function(key) {
const role = result[key].role;
if (role === 'owner') owner++;
if (role === 'manager') manager++;
if (role === 'user') user++;
if (role === 'guest') guest++;
});
log(Object.keys(result).length, 'Users', '(' + owner + ' Owner, ' + manager + ' Manager, ' + user + ' User, ' + guest + ' Guest)');
})
.catch(() => log('Failed: Getting users'));
await Homey.apps.getApps()
.then(result => {
let sdkv2Apps = [], sdkv3Apps = [], updateableApps = [], disabledApps = [], stableApps = [], testApps = [], devApps = [];
Object.keys(result).forEach(function(key) {
if (result[key].updateAvailable) updateableApps.push(result[key].name);
if (result[key].sdk === 2) sdkv2Apps.push(result[key].name);
if (
result[key].sdk === 3
|| homeyPlatformVersion === 2
) {
sdkv3Apps.push(result[key].name);
}
if (!result[key].ready) disabledApps.push(result[key].name);
if (result[key].origin === 'devkit_install') devApps.push(result[key].name);
else if (result[key].channel === 'stable' || result[key].channel === 'live') stableApps.push(result[key].name);
if (result[key].channel === 'beta' || result[key].channel === 'test') testApps.push(result[key].name);
});
log(Object.keys(result).length, 'Apps', '(' + stableApps.length + ' Stable, ' + testApps.length + ' Test, ' + devApps.length + ' Development/Community Appstore, ' + sdkv2Apps.length + ' SDKv2, ' + sdkv3Apps.length + ' SDKv3, ' + updateableApps.length + ' Updateable, ' + disabledApps.length + ' Disabled/Crashed)');
if (showStableApps) {
log('---------------------------------------------')
log('App(s) in the Stable channel:');
log(stableApps.join('\r\n'));
log('---------------------------------------------')
}
if (showTestApps) {
log('---------------------------------------------')
log('App(s) in the Test channel:');
log(testApps.join('\r\n'));
log('---------------------------------------------')
}
if (showDevApps) {
log('---------------------------------------------')
log('App(s) that are installed via CLI or Community Appstore:');
log(devApps.join('\r\n'));
log('---------------------------------------------')
}
if (showSDKv2Apps) {
log('---------------------------------------------')
log('SDKv2 app(s):');
log(sdkv2Apps.join('\r\n'));
log('---------------------------------------------')
}
if (showSDKv3Apps) {
log('---------------------------------------------')
log('SDKv3 app(s):');
log(sdkv3Apps.join('\r\n'));
log('---------------------------------------------')
}
if (showUpdateableApps) {
log('---------------------------------------------')
log('Updateable app(s):');
log(updateableApps.join('\r\n'));
log('---------------------------------------------')
}
if (showDisabledApps) {
log('---------------------------------------------')
log('Disabled app(s):');
log(disabledApps.join('\r\n'));
log('---------------------------------------------')
}
})
.catch(() => log('Failed: Getting apps'));
let zones = {};
await Homey.zones.getZones()
.then(result => {
Object.keys(result).forEach(function(key) {
zones[result[key].id] = result[key].name;
});
log(Object.keys(result).length, 'Zones');
if (showZones) {
log('---------------------------------------------')
log('Zones:');
log(Object.entries(zones).sort((a, b) => a[1].localeCompare(b[1])).map(zone => zone[1]).join('\r\n'));
log('---------------------------------------------')
}
})
.catch(() => log('Failed: Getting zones'));
await Homey.notifications.getNotifications()
.then(result => log(Object.keys(result).length || 0, 'Notifications (Timeline)'))
.catch(() => log('Failed: Getting notifications'));
await Homey.insights.getLogs()
.then(result => {
let boolean = 0, number = 0;
Object.keys(result).forEach(function(key) {
if (result[key].type === 'number') number++;
if (result[key].type === 'boolean') boolean++;
});
log(Object.keys(result).length, 'Insight entries', '(' + boolean + ' Boolean (Yes/No), ' + number + ' Number)');
})
.catch(() => log('Failed: Getting Insights'));
await Homey.logic.getVariables()
.then(result => {
let boolean = [], number = [], string = [];
Object.keys(result).forEach(function(key) {
if (result[key].type === 'boolean') boolean.push(result[key].name + ' (ID: ' + result[key].id + ')');
if (result[key].type === 'number') number.push(result[key].name + ' (ID: ' + result[key].id + ')');
if (result[key].type === 'string') string.push(result[key].name + ' (ID: ' + result[key].id + ')');
});
log(Object.keys(result).length, 'Logic Variables', '(' + boolean.length + ' Boolean (Yes/No), ' + number.length + ' Number, ' + string.length + ' String (Text))');
if (showLogicBoolean) {
log('---------------------------------------------')
log('Boolean (yes/no) variable(s):');
log(boolean.join('\r\n'));
log('---------------------------------------------')
}
if (showLogicNumber) {
log('---------------------------------------------')
log('Number variable(s):');
log(number.join('\r\n'));
log('---------------------------------------------')
}
if (showLogicString) {
log('---------------------------------------------')
log('String (text) variable(s):');
log(string.join('\r\n'));
log('---------------------------------------------')
}
})
.catch(() => log('Failed: Getting variables'));
await Homey.flow.getFlows()
.then(result => {
let disabledFlows = [], brokenFlows = [];
Object.keys(result).forEach(function(key) {
if (!result[key].enabled) disabledFlows.push(result[key].name);
if (result[key].broken) brokenFlows.push(result[key].name);
});
log(Object.keys(result).length, 'Flows', '(' + brokenFlows.length + ' Broken, ' + disabledFlows.length + ' Disabled)');
if (showBrokenFlows) {
log('---------------------------------------------')
log('Broken flow name(s):');
log(brokenFlows.join('\r\n'));
log('---------------------------------------------')
}
if (showDisabledFlows) {
log('---------------------------------------------')
log('Disabled flow name(s):');
log(disabledFlows.join('\r\n'));
log('---------------------------------------------')
}
})
.catch(() => log('Failed: Getting flows'));
await Homey.flow.getAdvancedFlows()
.then(result => {
let disabledFlows = [], brokenFlows = [];
Object.keys(result).forEach(function(key) {
if (!result[key].enabled) disabledFlows.push(result[key].name);
if (result[key].broken) brokenFlows.push(result[key].name);
});
log(Object.keys(result).length, 'Advanced flows', '(' + brokenFlows.length + ' Broken, ' + disabledFlows.length + ' Disabled)');
if (showBrokenAdvancedFlows) {
log('---------------------------------------------')
log('Broken advanced flow name(s):');
log(brokenFlows.join('\r\n'));
log('---------------------------------------------')
}
if (showDisabledAdvancedFlows) {
log('---------------------------------------------')
log('Disabled advanced flow name(s):');
log(disabledFlows.join('\r\n'));
log('---------------------------------------------')
}
})
.catch(() => log('Failed: Getting advanced flows'));
if (homeyPlatformVersion === 2) {
await Homey.images.getImages()
.then(result => {
let images = [];
Object.keys(result).forEach(function(key) {
if (result[key].id !== 'dummy') {
images.push(result[key].url);
}
});
log(images.length, 'Images');
if (showImages) {
log('---------------------------------------------')
log('Image URL(s):');
log(images.join('\r\n'));
log('\r\n');
log('Images can also be found in the developer tools:');
log('https://tools.developer.homey.app/tools/images');
log('---------------------------------------------')
}
})
.catch(() => log('Failed: Getting images'));
}
if (homeyPlatformVersion === 2 && Homey.moods !== undefined) {
await Homey.moods.getMoods()
.then(result => {
let moods = [];
Object.keys(result).forEach(async function(key) {
moods.push(zones[result[key].zone] + ' : ' + result[key].name);
});
log(moods.length, 'Moods');
if (showMoods) {
log('---------------------------------------------')
log('Mood(s):');
log(moods.join('\r\n'));
log('---------------------------------------------')
}
})
.catch(() => log('Failed: Getting Moods'));
}
await Homey.alarms.getAlarms()
.then(result => {
let enabled = 0;
Object.keys(result).forEach(function(key) {
if (result[key].enabled) enabled++;
});
log(Object.keys(result).length, 'Alarms', '(' + enabled + ' Enabled)')
})
.catch(() => log('Failed: Getting alarms'));
await Homey.apps.getAppSettings({id: 'com.athom.homeyscript'})
.then(result => {
log(Object.keys(result.scripts).length, 'HomeyScript scripts', '(' + ((result.tokens) ? Object.keys(result.tokens).length : 0) + ' Token/Tag)');
})
.catch(() => {
if (homeyPlatformVersion === 2 && homeyVersion.localeCompare("10.0.0-rc.80", undefined, {numeric: true, preversion: ["rc"]}) < 0) {
log('Failed: Getting HomeyScript, Homey Pro (early 2023): getting information from apps is currently unavailable.');
}
else {
log('Failed: Getting HomeyScript');
}
});
await Homey.apps.getAppSettings({id: 'net.i-dev.betterlogic'})
.then(result => {
let boolean = 0, number = 0, string = 0;
Object.keys(result.variables).forEach(function(key) {
if (result.variables[key].type === 'boolean') boolean++;
if (result.variables[key].type === 'number') number++;
if (result.variables[key].type === 'string') string++;
});
log(Object.keys(result.variables).length, 'Better Logic Variables', '(' + boolean + ' Boolean (Yes/No), ' + number + ' Number, ' + string + ' String)');
})
.catch(() => {
if (homeyPlatformVersion === 2 && homeyVersion.localeCompare("10.0.0-rc.80", undefined, {numeric: true, preversion: ["rc"]}) < 0) {
log('Failed: Getting Better logic, Homey Pro (early 2023): getting information from apps is currently unavailable.');
}
});
log('\r\n----------------- Devices -------------------');
let allDevices = 0, other = 0, homeyBridge = 0, zwaveDevices = [], zwaveNodes = [], zwaveRouterDevices = [], zwaveBatteryDevices = [], zwaveSxDevices = [], zwaveS0Devices = [], zwaveS2AuthDevices = [], zwaveS2UnauthDevices = [], unavailableDevices = [];
await Homey.devices.getDevices()
.then(result => {
let virtualNames = [], irNames = [];
Object.keys(result).forEach(function(key) {
const device = result[key];
const virtualDeviceApps = [
'homey:app:com.arjankranenburg.virtual',
'homey:app:nl.qluster-it.DeviceCapabilities',
'homey:app:nl.fellownet.chronograph',
'homey:app:net.i-dev.betterlogic',
'homey:app:com.swttt.devicegroups',
'homey:app:com.sysInternals',
'homey:virtualdriver',
]
if (
device.hasOwnProperty('available')
&& device.available === false
) {
unavailableDevices.push(device.name + ' (' + device.unavailableMessage + ')');
}
if (device.driverId.includes('infraredbasic') || device.driverId.includes('homey:virtualdriverinfrared')) {
irNames.push(device.name);
}
else if (device.driverId.includes('homey:virtualdriverbridge')) {
homeyBridge++;
}
else if (virtualDeviceApps.some(app => app === device.driverUri || device.driverId.includes(app))) {
virtualNames.push(device.name);
}
else if (device.flags.includes('zwaveRoot')) {
zwaveDevices.push(device.name + ' (Node ID: ' + device.settings.zw_node_id + ')');
zwaveNodes.push(Number(device.settings.zw_node_id));
if (
device.settings.zw_battery === '✓'
|| device.energyObj.batteries
) {
zwaveBatteryDevices.push(device.name + ' (Node ID: ' + device.settings.zw_node_id + ')');
}
else {
zwaveRouterDevices.push(device.name + ' (Node ID: ' + device.settings.zw_node_id + ')');
}
switch(device.settings.zw_secure) {
case '⨯':
zwaveSxDevices.push(device.name + ' (Node ID: ' + device.settings.zw_node_id + ')');
break;
case '✓':
case 'S0':
zwaveS0Devices.push(device.name + ' (Node ID: ' + device.settings.zw_node_id + ')');
break;
case 'S2 (Unauthenticated)':
case 'Unauthenticated':
zwaveS2UnauthDevices.push(device.name + ' (Node ID: ' + device.settings.zw_node_id + ')');
break;
case 'S2 (Authenticated)':
case 'Authenticated':
zwaveS2AuthDevices.push(device.name + ' (Node ID: ' + device.settings.zw_node_id + ')');
break;
}
}
else if (
!device.flags.includes('zwave')
&& !device.flags.includes('zigbee')
) {
other++;
}
});
allDevices = virtualNames.length + irNames.length + zwaveDevices.length + other + homeyBridge;
log(unavailableDevices.length, 'Unavailable devices')
if (showUnavailableDevices) {
log('---------------------------------------------')
log('Unavailable device(s):');
log(unavailableDevices.sort((a, b) => a - b).join('\r\n'));
log('---------------------------------------------')
}
log(virtualNames.length, 'Virtual devices');
if (showVirtualDevices) {
log('---------------------------------------------')
log('Virtual device(s):');
log(virtualNames.sort((a, b) => a - b).join('\r\n'));
log('---------------------------------------------')
}
log(irNames.length, 'Infrared (database) devices');
if (showIRDevices) {
log('---------------------------------------------')
log('Infrared (database) device(s):');
log(irNames.sort((a, b) => a - b).join('\r\n'));
log('---------------------------------------------')
}
})
.catch(() => log('Failed: Getting devices'));
await Homey.zwave.getState()
.then(result => {
const unknownNodes = result.zw_state.nodes
.filter((el) => !zwaveNodes.includes(el))
.sort((a, b) => a - b)
.slice(1);
log(zwaveDevices.length, 'Z-Wave devices', '(' + zwaveSxDevices.length + ' Unsecure, ' + zwaveS0Devices.length + ' Secure (S0), ' + zwaveS2AuthDevices.length + ' Secure (S2 Authenticated), ' + zwaveS2UnauthDevices.length + ' Secure (S2 Unauthenticated), ' + zwaveRouterDevices.length + ' Router, ' + zwaveBatteryDevices.length + ' Battery, ' + result.zw_state.noAckNodes.length + ' Unreachable, ' + unknownNodes.length + ' Unknown)')
if (showZwaveDevices) {
log('---------------------------------------------')
log('Z-Wave device(s):');
log(zwaveDevices.join('\r\n'));
log('---------------------------------------------')
}
if (showZwaveRouterDevices) {
log('---------------------------------------------')
log('Z-Wave router device(s):');
log(zwaveRouterDevices.sort((a, b) => a - b).join('\r\n'));
log('---------------------------------------------')
}
if (showZwaveUnsecureDevices) {
log('---------------------------------------------')
log('Z-Wave unsecure device(s):');
log(zwaveSxDevices.sort((a, b) => a - b).join('\r\n'));
log('---------------------------------------------')
}
if (showZwaveSecureS0Devices) {
log('---------------------------------------------')
log('Z-Wave secure (S0) device(s):');
log(zwaveS0Devices.sort((a, b) => a - b).join('\r\n'));
log('---------------------------------------------')
}
if (showZwaveSecureS2AuthenticatedDevices) {
log('---------------------------------------------')
log('Z-Wave secure (S2) authenticated device(s):');
log(zwaveS2AuthDevices.sort((a, b) => a - b).join('\r\n'));
log('---------------------------------------------')
}
if (showZwaveSecureS2UnauthenticatedDevices) {
log('---------------------------------------------')
log('Z-Wave secure (S2) Unauthenticated device(s):');
log(zwaveS2Unauth.sort((a, b) => a - b).join('\r\n'));
log('---------------------------------------------')
}
if (showZwaveBatteryDevices) {
log('---------------------------------------------')
log('Z-Wave battery device(s):');
log(zwaveBatteryDevices.sort((a, b) => a - b).join('\r\n'));
log('---------------------------------------------')
}
if (showZwaveUnreachableNodes) {
log('---------------------------------------------')
log('Unreachable node(s):');
log('Node ID:', result.zw_state.noAckNodes.sort((a, b) => a - b).join('\r\nNode ID: '));
log('---------------------------------------------')
}
if (showZwaveUnknownNodes) {
log('---------------------------------------------')
log('Unknown node(s):');
log('Node ID:', unknownNodes.join('\r\nNode ID: '));
log('---------------------------------------------')
}
})
.catch(() => log('Failed: Getting Z-Wave state'));
let zigbee;
if (Homey.zigBee !== undefined) {
await Homey.zigBee.getState()
.then(result => {
zigbee = result;
})
.catch(async () => log('Failed: Getting ZigBee state'));
}
if (Homey.zigbee !== undefined) {
await Homey.zigbee.getState()
.then(result => {
zigbee = result;
})
.catch(async () => log('Failed: Getting Zigbee state'));
}
if (zigbee) {
let zigbeeDevices = [], routerDevices = [], endDevices = [];
Object.keys(zigbee.nodes).forEach(function(key) {
device = zigbee.nodes[key];
let deviceName = device.name;
if (showZigbeeLastSeen && device.hasOwnProperty('lastSeen')) {
const lastSeen = new Date(device.lastSeen).toLocaleString('en-GB', {timeZone: timezone, month: 'long', day: 'numeric', hour: '2-digit', minute: '2-digit'});
deviceName += ' (last seen: ' + lastSeen + ')';
}
zigbeeDevices.push(deviceName);
if (device.type.toLowerCase() === 'router') routerDevices.push(deviceName);
if (device.type.toLowerCase() === 'enddevice') endDevices.push(deviceName);
});
log(zigbeeDevices.length, 'Zigbee devices', '(' + routerDevices.length + ' Router, ' + endDevices.length + ' End device)');
if (showZigbeeNodes) {
log('---------------------------------------------')
log('ZigBee device(s):');
log(zigbeeDevices.join('\r\n'));
log('---------------------------------------------')
}
if (showZigbeeRouter) {
log('---------------------------------------------')
log('ZigBee router(s):');
log(routerDevices.sort((a, b) => a - b).join('\r\n'));
log('---------------------------------------------')
}
if (showZigbeeEndDevice) {
log('---------------------------------------------')
log('ZigBee end device(s):');
log(endDevices.sort((a, b) => a - b).join('\r\n'));
log('---------------------------------------------')
}
allDevices += zigbeeDevices.length;
};
log(homeyBridge, 'Homey bridges');
log(other, 'Other devices');
log(allDevices, 'Total devices')
return 'Overview finished';
