@enyo-energy/sunspec-sdk 0.0.21 → 0.0.23

package/dist/sunspec-modbus-client.js

@@ -16,7 +16,7 @@
  * - pad: 0x8000 (always returns this value)
  * - string: all registers 0x0000 (NULL)
  */
-import { SunspecModelId, SunspecBatteryChargeState, SunspecStorageControlMode } from "./sunspec-interfaces.js";
+import { SunspecModelId, SunspecBatteryChargeState, SunspecStorageControlMode, SunspecChargeSource, SunspecStorageMode } from "./sunspec-interfaces.js";
 import { EnergyAppModbusConnectionHealth } from "@enyo-energy/energy-app-sdk/dist/implementations/modbus/EnergyAppModbusConnectionHealth.js";
 import { EnergyAppModbusFaultTolerantReader } from "@enyo-energy/energy-app-sdk/dist/implementations/modbus/EnergyAppModbusFaultTolerantReader.js";
 import { EnergyAppModbusDataTypeConverter } from "@enyo-energy/energy-app-sdk/dist/implementations/modbus/EnergyAppModbusDataTypeConverter.js";
@@ -262,6 +262,52 @@ export class SunspecModbusClient {
             throw error;
         }
     }
+    /**
+     * Helper to write register value(s)
+     */
+    async writeRegisterValue(address, value, dataType = 'uint16') {
+        if (!this.modbusClient) {
+            throw new Error('Modbus client not initialized');
+        }
+        try {
+            // Convert value to array of register values
+            let registerValues;
+            if (Array.isArray(value)) {
+                // For arrays, use directly
+                registerValues = value;
+            }
+            else {
+                // For single values, convert based on data type
+                switch (dataType) {
+                    case 'uint32':
+                    case 'int32':
+                        // Split 32-bit value into two 16-bit registers
+                        const high = (value >>> 16) & 0xFFFF;
+                        const low = value & 0xFFFF;
+                        registerValues = [high, low];
+                        break;
+                    case 'int16':
+                        // For signed 16-bit, ensure proper representation
+                        registerValues = [value & 0xFFFF];
+                        break;
+                    case 'uint16':
+                    default:
+                        registerValues = [value & 0xFFFF];
+                        break;
+                }
+            }
+            // Write to holding registers
+            await this.modbusClient.writeMultipleRegisters(address, registerValues);
+            this.connectionHealth.recordSuccess();
+            console.log(`Successfully wrote value ${value} to register ${address}`);
+            return true;
+        }
+        catch (error) {
+            this.connectionHealth.recordFailure(error);
+            console.error(`Error writing register at address ${address}: ${error}`);
+            throw error;
+        }
+    }
     /**
      * Read inverter data from Model 103 (Three Phase)
      */
@@ -794,6 +840,145 @@ export class SunspecModbusClient {
             return null;
         }
     }
+    /**
+     * Write battery control settings to Model 124
+     */
+    async writeBatteryControls(controls) {
+        const model = this.findModel(SunspecModelId.Battery);
+        if (!model) {
+            console.error('Battery model 124 not found');
+            return false;
+        }
+        const baseAddr = model.address;
+        console.log(`Writing Battery Controls to Model 124 at base address: ${baseAddr}`);
+        try {
+            // Write storage control mode (Register 5)
+            if (controls.storCtlMod !== undefined) {
+                await this.writeRegisterValue(baseAddr + 5, controls.storCtlMod, 'uint16');
+                console.log(`Set storage control mode to 0x${controls.storCtlMod.toString(16)}`);
+            }
+            // Write charge source setting (Register 17)
+            if (controls.chaGriSet !== undefined) {
+                await this.writeRegisterValue(baseAddr + 17, controls.chaGriSet, 'uint16');
+                console.log(`Set charge source to ${controls.chaGriSet === SunspecChargeSource.GRID ? 'GRID' : 'PV'}`);
+            }
+            // Write maximum charge power (Register 2) - needs scale factor
+            if (controls.wChaMax !== undefined) {
+                const scaleFactorAddr = baseAddr + 18;
+                const scaleFactor = await this.readRegisterValue(scaleFactorAddr, 1, 'int16');
+                const scaledValue = Math.round(controls.wChaMax / Math.pow(10, scaleFactor));
+                await this.writeRegisterValue(baseAddr + 2, scaledValue, 'uint16');
+                console.log(`Set max charge power to ${controls.wChaMax}W (scaled: ${scaledValue})`);
+            }
+            // Write charge rate (Register 13) - needs scale factor
+            if (controls.inWRte !== undefined) {
+                const scaleFactorAddr = baseAddr + 25;
+                const scaleFactor = await this.readRegisterValue(scaleFactorAddr, 1, 'int16');
+                const scaledValue = Math.round(controls.inWRte / Math.pow(10, scaleFactor));
+                await this.writeRegisterValue(baseAddr + 13, scaledValue, 'int16');
+                console.log(`Set charge rate to ${controls.inWRte}% (scaled: ${scaledValue})`);
+            }
+            // Write discharge rate (Register 12) - needs scale factor
+            if (controls.outWRte !== undefined) {
+                const scaleFactorAddr = baseAddr + 25;
+                const scaleFactor = await this.readRegisterValue(scaleFactorAddr, 1, 'int16');
+                const scaledValue = Math.round(controls.outWRte / Math.pow(10, scaleFactor));
+                await this.writeRegisterValue(baseAddr + 12, scaledValue, 'int16');
+                console.log(`Set discharge rate to ${controls.outWRte}% (scaled: ${scaledValue})`);
+            }
+            // Write minimum reserve percentage (Register 7) - needs scale factor
+            if (controls.minRsvPct !== undefined) {
+                const scaleFactorAddr = baseAddr + 21;
+                const scaleFactor = await this.readRegisterValue(scaleFactorAddr, 1, 'int16');
+                const scaledValue = Math.round(controls.minRsvPct / Math.pow(10, scaleFactor));
+                await this.writeRegisterValue(baseAddr + 7, scaledValue, 'uint16');
+                console.log(`Set minimum reserve to ${controls.minRsvPct}% (scaled: ${scaledValue})`);
+            }
+            console.log('Battery controls written successfully');
+            return true;
+        }
+        catch (error) {
+            console.error(`Error writing battery controls: ${error}`);
+            return false;
+        }
+    }
+    /**
+     * Set battery storage mode (simplified interface)
+     */
+    async setStorageMode(mode) {
+        let storCtlMod;
+        switch (mode) {
+            case SunspecStorageMode.CHARGE:
+                // Enable charge only (bit 0 = 1, bit 1 = 0)
+                storCtlMod = SunspecStorageControlMode.CHARGE;
+                break;
+            case SunspecStorageMode.DISCHARGE:
+                // Enable discharge only (bit 0 = 0, bit 1 = 1)
+                storCtlMod = SunspecStorageControlMode.DISCHARGE;
+                break;
+            case SunspecStorageMode.HOLDING:
+                // Disable both charge and discharge (bits 0 and 1 = 0)
+                storCtlMod = 0;
+                break;
+            case SunspecStorageMode.AUTO:
+                // Enable both charge and discharge (bits 0 and 1 = 1)
+                storCtlMod = SunspecStorageControlMode.CHARGE | SunspecStorageControlMode.DISCHARGE;
+                break;
+            default:
+                console.error(`Invalid storage mode: ${mode}`);
+                return false;
+        }
+        console.log(`Setting storage mode to ${mode} (control bits: 0x${storCtlMod.toString(16)})`);
+        return this.writeBatteryControls({ storCtlMod });
+    }
+    /**
+     * Enable or disable grid charging
+     */
+    async enableGridCharging(enable) {
+        const chaGriSet = enable ? SunspecChargeSource.GRID : SunspecChargeSource.PV;
+        console.log(`${enable ? 'Enabling' : 'Disabling'} grid charging`);
+        return this.writeBatteryControls({ chaGriSet });
+    }
+    /**
+     * Read current battery control settings
+     */
+    async readBatteryControls() {
+        const model = this.findModel(SunspecModelId.Battery);
+        if (!model) {
+            console.log('Battery model 124 not found');
+            return null;
+        }
+        const baseAddr = model.address;
+        console.log(`Reading Battery Controls from Model 124 at base address: ${baseAddr}`);
+        try {
+            // Read scale factors
+            const scaleFactors = {
+                WChaMax_SF: await this.readRegisterValue(baseAddr + 18, 1, 'int16'),
+                MinRsvPct_SF: await this.readRegisterValue(baseAddr + 21, 1, 'int16'),
+                InOutWRte_SF: await this.readRegisterValue(baseAddr + 25, 1, 'int16')
+            };
+            // Read raw values
+            const wChaMaxRaw = await this.readRegisterValue(baseAddr + 2, 1, 'uint16');
+            const storCtlModRaw = await this.readRegisterValue(baseAddr + 5, 1, 'uint16');
+            const minRsvPctRaw = await this.readRegisterValue(baseAddr + 7, 1, 'uint16');
+            const outWRteRaw = await this.readRegisterValue(baseAddr + 12, 1, 'int16');
+            const inWRteRaw = await this.readRegisterValue(baseAddr + 13, 1, 'int16');
+            const chaGriSetRaw = await this.readRegisterValue(baseAddr + 17, 1, 'uint16');
+            // Apply scale factors and return control settings
+            return {
+                storCtlMod: !this.isUnimplementedValue(storCtlModRaw, 'bitfield16') ? storCtlModRaw : undefined,
+                chaGriSet: !this.isUnimplementedValue(chaGriSetRaw, 'enum16') ? chaGriSetRaw : undefined,
+                wChaMax: this.applyScaleFactor(wChaMaxRaw, scaleFactors.WChaMax_SF, 'uint16'),
+                inWRte: this.applyScaleFactor(inWRteRaw, scaleFactors.InOutWRte_SF, 'int16'),
+                outWRte: this.applyScaleFactor(outWRteRaw, scaleFactors.InOutWRte_SF, 'int16'),
+                minRsvPct: this.applyScaleFactor(minRsvPctRaw, scaleFactors.MinRsvPct_SF, 'uint16')
+            };
+        }
+        catch (error) {
+            console.error(`Error reading battery controls: ${error}`);
+            return null;
+        }
+    }
     /**
      * Read meter data (Model 203 for 3-phase)
      */

package/dist/version.d.ts

@@ -5,7 +5,7 @@
 /**
  * Current version of the enyo Energy App SDK.
  */
-export declare const SDK_VERSION = "0.0.21";
+export declare const SDK_VERSION = "0.0.23";
 /**
  * Gets the current SDK version.
  * @returns The semantic version string of the SDK

package/dist/version.js

@@ -5,7 +5,7 @@
 /**
  * Current version of the enyo Energy App SDK.
  */
-export const SDK_VERSION = '0.0.21';
+export const SDK_VERSION = '0.0.23';
 /**
  * Gets the current SDK version.
  * @returns The semantic version string of the SDK

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@enyo-energy/sunspec-sdk",
-  "version": "0.0.21",
+  "version": "0.0.23",
   "description": "enyo Energy Sunspec SDK",
   "type": "module",
   "main": "dist/index.js",
@@ -37,7 +37,7 @@
     "typescript": "^5.8.3"
   },
   "dependencies": {
-    "@enyo-energy/energy-app-sdk": "^0.0.43"
+    "@enyo-energy/energy-app-sdk": "^0.0.47"
   },
   "volta": {
     "node": "22.17.0"