homebridge-enphase-envoy 10.0.2-beta.21 → 10.0.2-beta.23

package/package.json

@@ -2,7 +2,7 @@
     "private": false,
     "displayName": "Enphase Envoy",
     "name": "homebridge-enphase-envoy",
-    "version": "10.0.2-beta.21",
+    "version": "10.0.2-beta.23",
     "description": "Homebridge plugin for Photovoltaic Energy System manufactured by Enphase.",
     "license": "MIT",
     "author": "grzegorz914",

package/src/envoydevice.js

@@ -1526,204 +1526,136 @@ class EnvoyDevice extends EventEmitter {
     }
 
     async updateInventory() {
-        if (this.enableDebugMode) this.emit('debug', `Requesting inventory`);
+        if (this.enableDebugMode) this.emit('debug', 'Requesting inventory');
 
         try {
             const response = await this.axiosInstance(ApiUrls.Inventory);
             const inventory = response.data;
-            if (this.enableDebugMode) this.emit('debug', `Inventory:`, inventory);
+            if (this.enableDebugMode) this.emit('debug', 'Inventory:', inventory);
+
+            const getPartNumber = (partNum) => PartNumbers[partNum] ?? partNum;
+            const parseDeviceCommon = (device) => ({
+                partNumber: getPartNumber(device.part_num),
+                installed: device.installed,
+                serialNumber: device.serial_num,
+                deviceStatus: device.device_status,
+                readingTime: device.last_rpt_date,
+                adminState: device.admin_state,
+                devType: device.dev_type,
+                createdDate: device.created_date,
+                imageLoadDate: device.img_load_date,
+                firmware: device.img_pnum_running,
+                ptpn: device.ptpn,
+                chaneId: device.chaneid,
+                producing: device.producing === true,
+                communicating: device.communicating === true,
+                provisioned: device.provisioned === true,
+                operating: device.operating === true,
+            });
 
-            //inventory keys
-            const inventoryKeys = inventory.map(device => device.type);
+            const parseMicroinverters = (devices) => devices.slice(0, 70).map(device => ({
+                type: 'pcu',
+                ...parseDeviceCommon(device),
+                deviceControl: device.device_control[0]?.gficlearset ?? false,
+                phase: device.phase
+            }));
 
-            //microinverters
-            const microinvertersSupported = inventoryKeys.includes('PCU');
-            const microinverters = microinvertersSupported ? inventory[0].devices.slice(0, 70) : []; // Limit to 70 pcu
-            const microinvertersInstalled = microinverters.length > 0;
-            if (microinvertersInstalled) {
-                const arr = [];
-                const type = inventory[0].type ?? 'pcu';
-                for (const pcu of microinverters) {
-                    const obj = {
-                        type: type,
-                        partNum: PartNumbers[pcu.part_num] ?? pcu.part_num,
-                        installed: pcu.installed,
-                        serialNumber: pcu.serial_num,
-                        deviceStatus: pcu.device_status,
-                        readingTime: pcu.last_rpt_date,
-                        adminState: pcu.admin_state,
-                        devType: pcu.dev_type,
-                        createdDate: pcu.created_date,
-                        imageLoadDate: pcu.img_load_date,
-                        firmware: pcu.img_pnum_running,
-                        ptpn: pcu.ptpn,
-                        chaneId: pcu.chaneid,
-                        deviceControl: pcu.device_control[0].gficlearset, //bool
-                        producing: pcu.producing === true,
-                        communicating: pcu.communicating === true,
-                        provisioned: pcu.provisioned === true,
-                        operating: pcu.operating === true,
-                        phase: pcu.phase
-                    };
-                    //add obj to pcu array
-                    arr.push(obj);
-                };
+            const parseAcBatteries = (devices) => devices.map(device => ({
+                type: 'acb',
+                ...parseDeviceCommon(device),
+                deviceControl: device.device_control,
+                sleepEnabled: device.sleep_enabled,
+                percentFull: device.percentFull,
+                maxCellTemp: device.maxCellTemp,
+                sleepMinSoc: device.sleep_min_soc,
+                sleepMaxSoc: device.sleep_max_soc,
+                chargeState: device.charge_status
+            }));
 
-                //add array to pv pcu
-                this.pv.inventory.pcus = arr;
-                this.feature.inventory.pcus.installed = true;
-                this.feature.inventory.pcus.count = microinverters.length;
-            }
-            //microinverters
-            this.feature.inventory.pcus.supported = microinvertersSupported;
+            const parseQRelays = (devices) => devices.map(device => {
+                const lines = device['line-count'] ?? 0;
+                return {
+                    type: 'nsrb',
+                    ...parseDeviceCommon(device),
+                    deviceControl: device.device_control,
+                    relay: ApiCodes[device.relay],
+                    relayState: device.relay === 'closed',
+                    reasonCode: device.reason_code,
+                    reason: device.reason,
+                    linesCount: lines,
+                    line1Connected: lines >= 1 ? device['line1-connected'] === true : false,
+                    line2Connected: lines >= 2 ? device['line2-connected'] === true : false,
+                    line3Connected: lines >= 3 ? device['line3-connected'] === true : false
+                };
+            });
 
-            //ac batteries
-            const acBatteriesSupported = inventoryKeys.includes('ACB');
-            const acBatteries = acBatteriesSupported ? inventory[1].devices : [];
-            const acBatteriesInstalled = acBatteries.length > 0;
-            if (acBatteriesInstalled) {
-                const arr = [];
-                const type = inventory[1].type ?? 'acb';
-                for (const acb of acBatteries) {
-                    const obj = {
-                        type: type,
-                        partNumber: PartNumbers[acb.part_num] ?? acb.part_num,
-                        installed: acb.installed,
-                        serialNumber: acb.serial_num,
-                        deviceStatus: acb.device_status,
-                        readingTime: acb.last_rpt_date,
-                        adminState: acb.admin_state,
-                        devType: acb.dev_type,
-                        createdDate: acb.created_date,
-                        imageLoadDate: acb.img_load_date,
-                        firmware: acb.img_pnum_running,
-                        ptpn: acb.ptpn,
-                        chaneId: acb.chaneid,
-                        deviceControl: acb.device_control,
-                        producing: acb.producing === true,
-                        communicating: acb.communicating === true,
-                        provisioned: acb.provisioned === true,
-                        operating: acb.operating === true,
-                        sleepEnabled: acb.sleep_enabled,
-                        percentFull: acb.percentFull,
-                        maxCellTemp: acb.maxCellTemp,
-                        sleepMinSoc: acb.sleep_min_soc,
-                        sleepMaxSoc: acb.sleep_max_soc,
-                        chargeState: acb.charge_status,
-                    };
-                    //add ac batteries to acb
-                    arr.push(obj);
+            const parseEnsembles = (devices) => devices.map((device, index) => {
+                const obj = {
+                    type: 'esub',
+                    ...parseDeviceCommon(device),
+                    installed: new Date(device.installed * 1000).toLocaleString(),
+                    readingTime: new Date(device.last_rpt_date * 1000).toLocaleString(),
+                    createdDate: new Date(device.created_date * 1000).toLocaleString(),
+                    imageLoadDate: new Date(device.img_load_date * 1000).toLocaleString(),
+                    deviceControl: device.device_control,
                 };
 
-                //add array to pv ac batteries
-                this.pv.inventory.acbs = arr;
-                this.feature.inventory.acbs.installed = true;
-                this.feature.inventory.acbs.count = acBatteries.length;
-            }
-            //ac batteries
-            this.feature.inventory.acbs.supported = acBatteriesSupported;
+                // update characteristics
+                this.ensemblesInventoryServices?.[index]
+                    ?.updateCharacteristic(Characteristic.Status, obj.deviceStatus)
+                    .updateCharacteristic(Characteristic.ReadingTime, obj.readingTime)
+                    .updateCharacteristic(Characteristic.Firmware, obj.firmware)
+                    .updateCharacteristic(Characteristic.Producing, obj.producing)
+                    .updateCharacteristic(Characteristic.Communicating, obj.communicating)
+                    .updateCharacteristic(Characteristic.Operating, obj.operating);
 
-            //qrelays
-            const qRelaysSupported = inventoryKeys.includes('NSRB');
-            const qRelays = qRelaysSupported ? inventory[2].devices : [];
-            const qRelaysInstalled = qRelays.length > 0;
-            if (qRelaysInstalled) {
-                const arr = [];
-                const type = inventory[2].type ?? 'nsrb';
-                for (const nsrb of qRelays) {
-                    const obj = {
-                        type: type,
-                        partNumber: PartNumbers[nsrb.part_num] ?? nsrb.part_num,
-                        installed: nsrb.installed,
-                        serialNumber: nsrb.serial_num,
-                        deviceStatus: nsrb.device_status,
-                        readingTime: nsrb.last_rpt_date,
-                        adminState: nsrb.admin_state,
-                        devType: nsrb.dev_type,
-                        createdDate: nsrb.created_date,
-                        imageLoadDate: nsrb.img_load_date,
-                        firmware: nsrb.img_pnum_running,
-                        ptpn: nsrb.ptpn,
-                        chaneId: nsrb.chaneid,
-                        deviceControl: nsrb.device_control,
-                        producing: nsrb.producing === true,
-                        communicating: nsrb.communicating === true,
-                        provisioned: nsrb.provisioned === true,
-                        operating: nsrb.operating === true,
-                        relay: ApiCodes[nsrb.relay],
-                        relayState: nsrb.relay === 'closed',
-                        reasonCode: nsrb.reason_code,
-                        reason: nsrb.reason,
-                        linesCount: nsrb['line-count'],
-                        line1Connected: nsrb['line-count'] >= 1 ? nsrb['line1-connected'] === true : false,
-                        line2Connected: nsrb['line-count'] >= 2 ? nsrb['line2-connected'] === true : false,
-                        line3Connected: nsrb['line-count'] >= 3 ? nsrb['line3-connected'] === true : false
-                    };
-                    //add qRelay to nsrb
-                    arr.push(obj);
-                };
+                return obj;
+            });
+
+            const inventoryKeys = inventory.map(i => i.type);
+            const getDevicesByType = (type) => inventory.find(i => i.type === type)?.devices ?? [];
 
-                //add array to pv qrelays
-                this.pv.inventory.nsrbs = arr;
-                this.feature.inventory.nsrbs.installed = true;
-                this.feature.inventory.nsrbs.count = qRelays.length;
+            // Microinverters
+            const microinverters = getDevicesByType('PCU');
+            this.feature.inventory.pcus.supported = inventoryKeys.includes('PCU');
+            this.feature.inventory.pcus.installed = microinverters.length > 0;
+            if (this.feature.inventory.pcus.installed) {
+                this.pv.inventory.pcus = parseMicroinverters(microinverters);
+                this.feature.inventory.pcus.count = microinverters.length;
             }
-            //qRelays
-            this.feature.inventory.nsrbs.supported = qRelaysSupported;
 
-            //ensembles
-            const ensemblesSupported = inventoryKeys.includes('ESUB');
-            const ensembles = ensemblesSupported ? inventory[3].devices : [];
-            const ensemblesInstalled = ensembles.length > 0;
-            if (ensemblesInstalled) {
-                const arr = [];
-                const type = inventory[3].type ?? 'esub';
-                for (const [index, esub] of ensembles.entries()) {
-                    const obj = {
-                        type: type,
-                        partNumber: PartNumbers[esub.part_num] ?? esub.part_num,
-                        installed: new Date(esub.installed * 1000).toLocaleString(),
-                        serialNumber: esub.serial_num,
-                        deviceStatus: esub.device_status,
-                        readingTime: new Date(esub.last_rpt_date * 1000).toLocaleString(),
-                        adminState: esub.admin_state,
-                        devType: esub.dev_type,
-                        createdDate: new Date(esub.created_date * 1000).toLocaleString(),
-                        imageLoadDate: new Date(esub.img_load_date * 1000).toLocaleString(),
-                        firmware: esub.img_pnum_running,
-                        ptpn: esub.ptpn,
-                        chaneId: esub.chaneid,
-                        deviceControl: esub.device_control,
-                        producing: esub.producing === true,
-                        communicating: esub.communicating === true,
-                        operating: esub.operating === true
-                    };
-                    //add obj to ensemble object
-                    arr.push(obj);
+            // AC Batteries
+            const acbs = getDevicesByType('ACB');
+            this.feature.inventory.acbs.supported = inventoryKeys.includes('ACB');
+            this.feature.inventory.acbs.installed = acbs.length > 0;
+            if (this.feature.inventory.acbs.installed) {
+                this.pv.inventory.acbs = parseAcBatteries(acbs);
+                this.feature.inventory.acbs.count = acbs.length;
+            }
 
-                    //update chaaracteristics
-                    this.ensemblesInventoryServices?.[index]
-                        ?.updateCharacteristic(Characteristic.Status, obj.deviceStatus)
-                        .updateCharacteristic(Characteristic.ReadingTime, obj.readingTime)
-                        .updateCharacteristic(Characteristic.Firmware, obj.firmware)
-                        .updateCharacteristic(Characteristic.Producing, obj.producing)
-                        .updateCharacteristic(Characteristic.Communicating, obj.communicating)
-                        .updateCharacteristic(Characteristic.Operating, obj.operating);
-                };
+            // Q-Relays
+            const nsrbs = getDevicesByType('NSRB');
+            this.feature.inventory.nsrbs.supported = inventoryKeys.includes('NSRB');
+            this.feature.inventory.nsrbs.installed = nsrbs.length > 0;
+            if (this.feature.inventory.nsrbs.installed) {
+                this.pv.inventory.nsrbs = parseQRelays(nsrbs);
+                this.feature.inventory.nsrbs.count = nsrbs.length;
+            }
 
-                //add array to pv ensembles
-                this.pv.inventory.esubs = arr;
-                this.feature.inventory.esubs.installed = true;
-                this.feature.inventory.esubs.count = ensembles.length;
+            // Ensembles
+            const esubs = getDevicesByType('ESUB');
+            this.feature.inventory.esubs.supported = inventoryKeys.includes('ESUB');
+            this.feature.inventory.esubs.installed = esubs.length > 0;
+            if (this.feature.inventory.esubs.installed) {
+                this.pv.inventory.esubs = parseEnsembles(esubs);
+                this.feature.inventory.esubs.count = esubs.length;
             }
-            //ensembles
-            this.feature.inventory.esubs.supported = ensemblesSupported;
 
-            //inventory supported
+            // Inventory globally supported
             this.feature.inventory.supported = true;
 
-            // RESTFul and MQTT update
-            if (this.restFulConnected) this.restFul1.update('inventory', inventory)
+            // RESTful & MQTT publishing
+            if (this.restFulConnected) this.restFul1.update('inventory', inventory);
             if (this.mqttConnected) this.mqtt1.emit('publish', 'Inventory', inventory);
 
             return true;
@@ -1732,6 +1664,7 @@ class EnvoyDevice extends EventEmitter {
         }
     }
 
+
     async updatePcuStatus() {
         if (this.enableDebugMode) this.emit('debug', `Requesting pcu status`);
 
@@ -2743,44 +2676,24 @@ class EnvoyDevice extends EventEmitter {
 
         try {
             const response = await this.axiosInstance(ApiUrls.SystemReadingStats);
-            const productionCtData = response.data;
-            if (this.enableDebugMode) this.emit('debug', `Production ct:`, productionCtData);
-
-            // Flags and constants
-            const meterConsumptionNetEnabled = this.feature.meters.consumption.net.enabled;
-            const acBatteriesInstalled = this.feature.inventory.acbs.installed;
-            const productionCtKeys = Object.keys(productionCtData);
-
-            // Production Supported?
-            const productionCtProductionExist = productionCtKeys.includes('production');
-            if (productionCtProductionExist) {
-                // PCU data at index 0
-                const productionPcu = productionCtData.production[0] ?? [];
-                const productionPcuSupported = productionPcu.length > 0;
-                if (productionPcuSupported) {
-                    const obj = {
-                        type: 'pcu',
-                        activeCount: productionPcu.activeCount,
-                        measurementType: 'Production',
-                        readingTime: productionPcu.readingTime,
-                        power: productionPcu.wNow,
-                        energyToday: 0,
-                        energyLastSevenDays: 0,
-                        energyLifetime: productionPcu.whLifetime
-                    };
-                    //this.pv.powerAndEnergy.production.pcu = obj;
+            const data = response.data;
+            if (this.enableDebugMode) this.emit('debug', `Production ct:`, data);
+
+            const keys = Object.keys(data);
+
+            // --- Production: PCU ---
+            if (keys.includes('production') && Array.isArray(data.production)) {
+                const productionPcu = data.production[0];
+                if (productionPcu) {
                     this.feature.productionCt.production.pcu.supported = true;
                 }
 
-                // EIM data at index 1
-                const productionEim = productionCtData.production[1] ?? [];
-                const productionEimSupported = productionEim.length > 0;
-                if (productionEimSupported) {
-                    const measurementType = ApiCodes[productionEim.measurementType];
+                const productionEim = data.production[1];
+                if (productionEim) {
                     const obj = {
                         type: 'eim',
                         activeCount: 1,
-                        measurementType: measurementType,
+                        measurementType: ApiCodes[productionEim.measurementType],
                         readingTime: productionEim.readingTime,
                         power: productionEim.wNow,
                         energyToday: productionEim.whToday,
@@ -2797,63 +2710,61 @@ class EnvoyDevice extends EventEmitter {
                 }
             }
 
-            // Consumption data
-            const consumptionExist = productionCtKeys.includes('consumption');
-            const consumptionSupported = consumptionExist && productionCtData.consumption?.length > 0;
-            if (consumptionSupported && meterConsumptionNetEnabled) {
-                for (const consumption of productionCtData.consumption) {
-                    const measurementType = ApiCodes[consumption.measurementType];
-                    const key = MetersKeyMap[measurementType];
-
+            // --- Consumption: EIM ---
+            if (keys.includes('consumption') && Array.isArray(data.consumption) && this.feature.meters.consumption.net.enabled) {
+                for (const item of data.consumption) {
+                    const type = ApiCodes[item.measurementType];
+                    const key = MetersKeyMap[type];
                     const obj = {
                         type: 'eim',
-                        measurementType: measurementType,
+                        measurementType: type,
                         activeCount: 1,
-                        readingTime: consumption.readingTime,
-                        power: consumption.wNow,
-                        energyToday: consumption.whToday,
-                        energyLastSevenDays: consumption.whLastSevenDays,
-                        energyLifetime: consumption.whLifetime,
-                        reactivePower: consumption.reactPwr,
-                        apparentPower: consumption.apprntPwr,
-                        current: consumption.rmsCurrent,
-                        voltage: consumption.rmsVoltage,
-                        pwrFactor: consumption.pwrFactor
+                        readingTime: item.readingTime,
+                        power: item.wNow,
+                        energyToday: item.whToday,
+                        energyLastSevenDays: item.whLastSevenDays,
+                        energyLifetime: item.whLifetime,
+                        reactivePower: item.reactPwr,
+                        apparentPower: item.apprntPwr,
+                        current: item.rmsCurrent,
+                        voltage: item.rmsVoltage,
+                        pwrFactor: item.pwrFactor
                     };
                     this.pv.powerAndEnergy.consumption.eim[key] = obj;
                     this.feature.productionCt.consumption.eim[key].supported = true;
                 }
             }
 
-            // AC Batteries summary
-            const acBatterieExist = productionCtKeys.includes('storage');
-            const acBatterieSupported = acBatterieExist && productionCtData.storage?.length > 0;
-            if (acBatterieSupported && acBatteriesInstalled) {
-                for (const acb of productionCtData.storage) {
-
+            // --- Storage: ACB Summary ---
+            if (keys.includes('storage') && Array.isArray(data.storage) && this.feature.inventory.acbs.installed) {
+                const summary = data.storage[0];
+                if (summary) {
                     const obj = {
                         type: 'acb',
                         measurementType: 'Storage',
-                        activeCount: acb.activeCount,
-                        readingTime: acb.readingTime,
-                        powerSum: acb.wNow,
-                        energySum: acb.whNow,
-                        chargeStateSum: acb.state
+                        activeCount: summary.activeCount,
+                        readingTime: summary.readingTime,
+                        powerSum: summary.wNow,
+                        energySum: summary.whNow,
+                        chargeStateSum: summary.state
                     };
+                    this.feature.productionCt.storage.supported = true;
 
-                    for (let i = 0; i < this.feature.inventory.acbs.count; i++) {
-                        this.pv.inventory.acbs[i] = { ...this.pv.inventory.acbs[i], ...obj };
+                    // Merge into each ACB in inventory
+                    for (let i = 0; i < this.pv.inventory.acbs.length; i++) {
+                        this.pv.inventory.acbs[i] = {
+                            ...this.pv.inventory.acbs[i],
+                            ...obj
+                        };
                     }
                 }
-                this.feature.productionCt.storage.supported = true;
             }
 
-            // Overall productionCt support
+            // --- Finalize ---
             this.feature.productionCt.supported = true;
 
-            // RESTFul and MQTT update
-            if (this.restFulConnected) this.restFul1.update('productionct', productionCtData);
-            if (this.mqttConnected) this.mqtt1.emit('publish', 'Production CT', productionCtData);
+            if (this.restFulConnected) this.restFul1.update('productionct', data);
+            if (this.mqttConnected) this.mqtt1.emit('publish', 'Production CT', data);
 
             return true;
         } catch (error) {
@@ -2861,6 +2772,7 @@ class EnvoyDevice extends EventEmitter {
         }
     }
 
+
     async updatePowerAndEnergyData() {
         if (this.enableDebugMode) this.emit('debug', `Requesting power and energy data`);
 
@@ -7945,7 +7857,6 @@ class EnvoyDevice extends EventEmitter {
             const updateDetailedDevicesData = updateInventory || this.feature.meters.installed ? await this.updateDetailedDevicesData(true) : false;
             const pcusData = updateInventory ? await this.updatePcusData() : false;
             const nsrbsData = updateInventory ? await this.updateNsrbsData() : false;
-            const acbsData = this.feature.inventory.acbs.installed ? await this.updateAcbsData() : false;
 
             // Production
             const refreshProduction = this.feature.info.firmware < 824 ? await this.updateProduction() : false;
@@ -7954,6 +7865,9 @@ class EnvoyDevice extends EventEmitter {
             const refreshProductionCt = this.feature.inventory.acbs.installed || this.feature.meters.installed ? await this.updateProductionCt() : false;
             const refreshProductionData = await this.updatePowerAndEnergyData();
 
+            // Battery   
+            const acbsData = this.feature.inventory.acbs.installed ? await this.updateAcbsData() : false;
+
             // Ensemble (FW >= 7.x.x)
             const refreshEnsemble = firmware7xx && this.feature.inventory.esubs.supported ? await this.updateEnsembleInventory() : false;
             const updateEnsembleStatus = refreshEnsemble && this.feature.ensemble.installed ? await this.updateEnsembleStatus() : false;