const ModbusRTU = require('modbus-serial');
const client = new ModbusRTU();

// RTU: await client.connectRTUBuffered("/dev/ttyUSB0", { baudRate: 9600 });
await client.connectTCP("192.168.1.100", { port: 502 });
client.setID(1);

function signed16(v) { return v >= 32768 ? v - 65536 : v; }

setInterval(async () => {
    // Group 1: inverter basics
    const g1 = await client.readHoldingRegisters(10000, 4);
    const freq = g1.data[0] * 0.01;        // Hz
    const vA = g1.data[1] * 0.1;           // V

    // Group 2: PV production
    const g2 = await client.readHoldingRegisters(10087, 5);
    const pvTotal = g2.data[0] * 0.01;     // kW
    const pv1V = g2.data[1] * 0.1;         // V

    // Group 3: battery
    const g3 = await client.readHoldingRegisters(10671, 5);
    const soc = g3.data[0] * 0.01;         // %
    const batCur = signed16(g3.data[4]) * 0.1; // A

    // Meter power (+import / -export)
    const m = await client.readHoldingRegisters(10765, 1);
    const meterW = signed16(m.data[0]) * 0.01; // kW

    // PCS working status
    const s = await client.readHoldingRegisters(14002, 1);
    console.log(`PV:${pvTotal.toFixed(2)}kW SOC:${soc.toFixed(0)}% `
              + `Meter:${meterW.toFixed(2)}kW Freq:${freq.toFixed(1)}Hz`);
}, 1000);

using NModbus;
using System.Net.Sockets;

// RTU: var port = new SerialPort("/dev/ttyUSB0", 9600);
//      var master = factory.CreateRtuMaster(port);
var tcp = new TcpClient("192.168.1.100", 502);
var factory = new ModbusFactory();
var master = factory.CreateMaster(tcp);

short Signed16(ushort v) => v >= 32768 ? (short)(v - 65536) : (short)v;

while (true) {
    // Group 1: inverter basics (10000-10003)
    var g1 = master.ReadHoldingRegisters(1, 10000, 4);
    double freq = g1[0] * 0.01;            // Hz
    double vA   = g1[1] * 0.1;             // V

    // Group 2: PV production (10087-10091)
    var g2 = master.ReadHoldingRegisters(1, 10087, 5);
    double pvTotal = g2[0] * 0.01;         // kW

    // Group 3: battery (10671-10675)
    var g3 = master.ReadHoldingRegisters(1, 10671, 5);
    double soc    = g3[0] * 0.01;          // %
    double batCur = Signed16(g3[4]) * 0.1; // A

    // Meter power
    var m = master.ReadHoldingRegisters(1, 10765, 1);
    double meterW = Signed16(m[0]) * 0.01; // kW (+imp/-exp)

    Console.WriteLine($"PV:{pvTotal:F2}kW SOC:{soc:F0}% Meter:{meterW:F2}kW");
    Thread.Sleep(1000);
}

package main
import (
    "fmt"; "time"
    "github.com/goburrow/modbus"
    "encoding/binary"
)

func signed16(v uint16) int16 { return int16(v) }

func main() {
    // RTU: handler := modbus.NewRTUClientHandler("/dev/ttyUSB0")
    handler := modbus.NewTCPClientHandler("192.168.1.100:502")
    handler.SlaveId = 1
    handler.Connect()
    defer handler.Close()
    client := modbus.NewClient(handler)

    for {
        // Group 1: inverter basics
        g1, _ := client.ReadHoldingRegisters(10000, 4)
        freq := float64(binary.BigEndian.Uint16(g1[0:2])) * 0.01

        // Group 2: PV production
        g2, _ := client.ReadHoldingRegisters(10087, 5)
        pvTotal := float64(binary.BigEndian.Uint16(g2[0:2])) * 0.01

        // Group 3: battery SOC and current
        g3, _ := client.ReadHoldingRegisters(10671, 5)
        soc := float64(binary.BigEndian.Uint16(g3[0:2])) * 0.01
        batCur := float64(signed16(binary.BigEndian.Uint16(g3[8:10]))) * 0.1

        // Meter power (+import / -export)
        m, _ := client.ReadHoldingRegisters(10765, 1)
        meterW := float64(signed16(binary.BigEndian.Uint16(m[0:2]))) * 0.01

        fmt.Printf("PV:%.2fkW SOC:%.0f%% Meter:%.2fkW Freq:%.1fHz\n",
            pvTotal, soc, meterW, freq)
        time.Sleep(1 * time.Second)
    }
}

const ModbusRTU = require('modbus-serial');
const client = new ModbusRTU();

// RTU: await client.connectRTUBuffered("/dev/ttyUSB0", { baudRate: 9600 });
await client.connectTCP("192.168.1.100", { port: 502 });
client.setID(1);

function signed16(v) { return v >= 32768 ? v - 65536 : v; }
function toUnsigned(v) { return v < 0 ? v + 65536 : v; }

// Enable EMS and zero-export
await client.writeRegister(11060, 1);   // EMS on
await client.writeRegister(11107, 1);   // export limit on
await client.writeRegister(11113, 0);   // zero export

const MARGIN = 0.05; // 50W import bias
let powerSet = 0.0;

setInterval(async () => {
    const m = await client.readHoldingRegisters(10765, 1);
    const meterKw = signed16(m.data[0]) * 0.01;

    const s = await client.readHoldingRegisters(10671, 1);
    const soc = s.data[0] * 0.01;

    // Proportional control toward small import target
    const error = meterKw + MARGIN;
    powerSet = Math.max(-10, Math.min(10, powerSet + error * 0.5));

    // Anti-windup at SOC limits
    if (soc > 98 && powerSet < 0) powerSet = 0;
    if (soc < 10 && powerSet > 0) powerSet = 0;

    await client.writeRegister(11045, toUnsigned(Math.round(powerSet * 100)));
    console.log(`Meter:${meterKw.toFixed(2)}kW SOC:${soc.toFixed(0)}% Set:${powerSet.toFixed(2)}kW`);
}, 1000);

using NModbus;
using System.Net.Sockets;

// RTU: var port = new SerialPort("/dev/ttyUSB0", 9600);
//      var master = factory.CreateRtuMaster(port);
var tcp = new TcpClient("192.168.1.100", 502);
var factory = new ModbusFactory();
var master = factory.CreateMaster(tcp);

short Signed16(ushort v) => v >= 32768 ? (short)(v - 65536) : (short)v;
ushort ToUnsigned(int v) => (ushort)(v < 0 ? v + 65536 : v);

// Enable EMS and zero-export limits
master.WriteSingleRegister(1, 11060, 1);   // EMS on
master.WriteSingleRegister(1, 11107, 1);   // export limit on
master.WriteSingleRegister(1, 11113, 0);   // zero export

double powerSet = 0.0;
const double MARGIN = 0.05; // 50W import bias

while (true) {
    var m = master.ReadHoldingRegisters(1, 10765, 1);
    double meterKw = Signed16(m[0]) * 0.01;
    var s = master.ReadHoldingRegisters(1, 10671, 1);
    double soc = s[0] * 0.01;

    double error = meterKw + MARGIN;
    powerSet = Math.Clamp(powerSet + error * 0.5, -10.0, 10.0);

    if (soc > 98 && powerSet < 0) powerSet = 0;  // anti-windup
    if (soc < 10 && powerSet > 0) powerSet = 0;

    master.WriteSingleRegister(1, 11045, ToUnsigned((int)(powerSet * 100)));
    Console.WriteLine($"Meter:{meterKw:+0.00}kW SOC:{soc:F0}% Set:{powerSet:+0.00}kW");
    Thread.Sleep(1000);
}

package main
import (
    "fmt"; "time"; "math"
    "github.com/goburrow/modbus"
    "encoding/binary"
)

func signed16(v uint16) int16 { return int16(v) }
func toUnsigned(v int16) uint16 { return uint16(v) }

func main() {
    // RTU: handler := modbus.NewRTUClientHandler("/dev/ttyUSB0")
    handler := modbus.NewTCPClientHandler("192.168.1.100:502")
    handler.SlaveId = 1
    handler.Connect()
    defer handler.Close()
    client := modbus.NewClient(handler)

    // Enable EMS and zero-export
    client.WriteSingleRegister(11060, 1) // EMS on
    client.WriteSingleRegister(11107, 1) // export limit on
    client.WriteSingleRegister(11113, 0) // zero export

    powerSet := 0.0
    margin := 0.05 // 50W import bias

    for {
        m, _ := client.ReadHoldingRegisters(10765, 1)
        meterKw := float64(signed16(binary.BigEndian.Uint16(m))) * 0.01

        s, _ := client.ReadHoldingRegisters(10671, 1)
        soc := float64(binary.BigEndian.Uint16(s)) * 0.01

        err := meterKw + margin
        powerSet = math.Max(-10, math.Min(10, powerSet+err*0.5))
        if soc > 98 && powerSet < 0 { powerSet = 0 }
        if soc < 10 && powerSet > 0 { powerSet = 0 }

        client.WriteSingleRegister(11045, toUnsigned(int16(powerSet*100)))
        fmt.Printf("Meter:%+.2fkW SOC:%.0f%% Set:%+.2fkW\n", meterKw, soc, powerSet)
        time.Sleep(1 * time.Second)
    }
}

const ModbusRTU = require('modbus-serial');
const client = new ModbusRTU();

// RTU: await client.connectRTUBuffered("/dev/ttyUSB0", { baudRate: 9600 });
await client.connectTCP("192.168.1.100", { port: 502 });
client.setID(1);

// Set TOU mode and SOC limits
await client.writeRegister(11151, 4);                    // TOU mode
await client.writeRegister(11108, Math.round(10 * 100)); // SOC_MIN = 10%
await client.writeRegister(11109, Math.round(100 * 100));// SOC_MAX = 100%
await client.writeRegister(11250, Math.round(5.0 * 100));// charge = 5kW

// Period 1: Valley 00:00-07:00 (charge during off-peak)
await client.writeRegisters(11190, [0, 420, 2]);

// Period 2: Flat 07:00-17:00
await client.writeRegisters(11193, [420, 1020, 0]);

// Period 3: Peak 17:00-23:00 (discharge during peak)
await client.writeRegisters(11196, [1020, 1380, 1]);

// All days of week (Mon-Sun)
await client.writeRegister(11254, 0x7F);

// Readback verification
const r = await client.readHoldingRegisters(11190, 9);
const labels = ['Flat', 'Peak', 'Valley'];
for (let i = 0; i < 3; i++) {
    const s = r.data[i*3], e = r.data[i*3+1], m = r.data[i*3+2];
    const fmt = (v) => `${String(Math.floor(v/60)).padStart(2,'0')}:${String(v%60).padStart(2,'0')}`;
    console.log(`Period ${i+1}: ${fmt(s)}-${fmt(e)} [${labels[m]}]`);
}
client.close();

using NModbus;
using System.Net.Sockets;

// RTU: var port = new SerialPort("/dev/ttyUSB0", 9600);
//      var master = factory.CreateRtuMaster(port);
var tcp = new TcpClient("192.168.1.100", 502);
var factory = new ModbusFactory();
var master = factory.CreateMaster(tcp);

// Set TOU mode and SOC limits
master.WriteSingleRegister(1, 11151, 4);                     // TOU mode
master.WriteSingleRegister(1, 11108, (ushort)(10.0 * 100));  // SOC_MIN=10%
master.WriteSingleRegister(1, 11109, (ushort)(100.0 * 100)); // SOC_MAX=100%
master.WriteSingleRegister(1, 11250, (ushort)(5.0 * 100));   // charge=5kW

// Period 1: Valley 00:00-07:00 (charge)
master.WriteMultipleRegisters(1, 11190, new ushort[] { 0, 420, 2 });
// Period 2: Flat 07:00-17:00
master.WriteMultipleRegisters(1, 11193, new ushort[] { 420, 1020, 0 });
// Period 3: Peak 17:00-23:00 (discharge)
master.WriteMultipleRegisters(1, 11196, new ushort[] { 1020, 1380, 1 });

// All days (Mon-Sun = 0x7F)
master.WriteSingleRegister(1, 11254, 0x7F);

// Readback verification
var r = master.ReadHoldingRegisters(1, 11190, 9);
string[] labels = { "Flat", "Peak", "Valley" };
for (int i = 0; i < 3; i++) {
    int s = r[i*3], e = r[i*3+1], m = r[i*3+2];
    Console.WriteLine($"Period {i+1}: {s/60:D2}:{s%60:D2}-{e/60:D2}:{e%60:D2} [{labels[m]}]");
}
tcp.Close();

package main
import (
    "fmt"
    "github.com/goburrow/modbus"
    "encoding/binary"
)

func main() {
    // RTU: handler := modbus.NewRTUClientHandler("/dev/ttyUSB0")
    handler := modbus.NewTCPClientHandler("192.168.1.100:502")
    handler.SlaveId = 1
    handler.Connect()
    defer handler.Close()
    client := modbus.NewClient(handler)

    // Set TOU mode, SOC limits, charge power
    client.WriteSingleRegister(11151, 4)          // TOU mode
    client.WriteSingleRegister(11108, uint16(10*100))  // SOC_MIN=10%
    client.WriteSingleRegister(11109, uint16(100*100)) // SOC_MAX=100%
    client.WriteSingleRegister(11250, uint16(5*100))   // charge=5kW

    // Period 1: Valley 00:00-07:00, Period 2: Flat 07:00-17:00, Period 3: Peak 17:00-23:00
    periods := []uint16{0, 420, 2, 420, 1020, 0, 1020, 1380, 1}
    buf := make([]byte, len(periods)*2)
    for i, v := range periods { binary.BigEndian.PutUint16(buf[i*2:], v) }
    client.WriteMultipleRegisters(11190, uint16(len(periods)), buf)

    client.WriteSingleRegister(11254, 0x7F) // all days

    // Readback
    r, _ := client.ReadHoldingRegisters(11190, 9)
    labels := []string{"Flat", "Peak", "Valley"}
    for i := 0; i < 3; i++ {
        s := binary.BigEndian.Uint16(r[i*6:])
        e := binary.BigEndian.Uint16(r[i*6+2:])
        m := binary.BigEndian.Uint16(r[i*6+4:])
        fmt.Printf("Period %d: %02d:%02d-%02d:%02d [%s]\n", i+1, s/60, s%60, e/60, e%60, labels[m])
    }
}

const ModbusRTU = require('modbus-serial');
const client = new ModbusRTU();

// RTU: await client.connectRTUBuffered("/dev/ttyUSB0", { baudRate: 9600 });
await client.connectTCP("192.168.1.100", { port: 502 });
client.setID(1);

function signed16(v) { return v >= 32768 ? v - 65536 : v; }
function toUnsigned(v) { return v < 0 ? v + 65536 : v; }

const DEMAND_LIMIT = 50.0; // kW contracted max
const SOC_RESERVE = 15.0;  // min battery reserve %

// Enable EMS and set demand limit
await client.writeRegister(11060, 1);
await client.writeRegister(11350, Math.round(DEMAND_LIMIT * 100));

// Verify
const lim = await client.readHoldingRegisters(14033, 1);
console.log(`Applied limit: ${(lim.data[0] * 0.01).toFixed(1)} kW`);

setInterval(async () => {
    const m = await client.readHoldingRegisters(10765, 1);
    const meterKw = signed16(m.data[0]) * 0.01;

    const s = await client.readHoldingRegisters(10671, 1);
    const soc = s.data[0] * 0.01;

    let discharge = 0;
    if (meterKw > DEMAND_LIMIT && soc > SOC_RESERVE) {
        discharge = meterKw - DEMAND_LIMIT;          // shave excess
    } else if (meterKw < 0) {
        discharge = -Math.abs(meterKw) * 0.5;        // charge with surplus
    }
    discharge = Math.max(-10, Math.min(10, discharge));

    await client.writeRegister(11045, toUnsigned(Math.round(discharge * 100)));
    console.log(`Meter:${meterKw.toFixed(1)}kW SOC:${soc.toFixed(0)}% Bat:${discharge.toFixed(1)}kW`);
}, 1000);

using NModbus;
using System.Net.Sockets;

// RTU: var port = new SerialPort("/dev/ttyUSB0", 9600);
//      var master = factory.CreateRtuMaster(port);
var tcp = new TcpClient("192.168.1.100", 502);
var factory = new ModbusFactory();
var master = factory.CreateMaster(tcp);

short Signed16(ushort v) => v >= 32768 ? (short)(v - 65536) : (short)v;
ushort ToUnsigned(int v) => (ushort)(v < 0 ? v + 65536 : v);

const double DemandLimit = 50.0; // kW
const double SocReserve = 15.0;  // %

master.WriteSingleRegister(1, 11060, 1);                         // EMS on
master.WriteSingleRegister(1, 11350, (ushort)(DemandLimit * 100));

// Verify applied limit
var lim = master.ReadHoldingRegisters(1, 14033, 1);
Console.WriteLine($"Applied limit: {lim[0] * 0.01:F1} kW");

while (true) {
    var m = master.ReadHoldingRegisters(1, 10765, 1);
    double meterKw = Signed16(m[0]) * 0.01;
    var s = master.ReadHoldingRegisters(1, 10671, 1);
    double soc = s[0] * 0.01;

    double discharge = 0;
    if (meterKw > DemandLimit && soc > SocReserve)
        discharge = meterKw - DemandLimit;
    else if (meterKw < 0)
        discharge = -Math.Abs(meterKw) * 0.5;
    discharge = Math.Clamp(discharge, -10.0, 10.0);

    master.WriteSingleRegister(1, 11045, ToUnsigned((int)(discharge * 100)));
    Console.WriteLine($"Meter:{meterKw:F1}kW SOC:{soc:F0}% Bat:{discharge:+F1}kW");
    Thread.Sleep(1000);
}

package main
import (
    "fmt"; "time"; "math"
    "github.com/goburrow/modbus"
    "encoding/binary"
)

func signed16(v uint16) int16 { return int16(v) }
func toUnsigned(v int16) uint16 { return uint16(v) }

func main() {
    // RTU: handler := modbus.NewRTUClientHandler("/dev/ttyUSB0")
    handler := modbus.NewTCPClientHandler("192.168.1.100:502")
    handler.SlaveId = 1
    handler.Connect()
    defer handler.Close()
    client := modbus.NewClient(handler)

    demandLimit := 50.0 // kW contracted max
    socReserve := 15.0  // min SOC %

    client.WriteSingleRegister(11060, 1)                       // EMS on
    client.WriteSingleRegister(11350, uint16(demandLimit*100)) // set limit

    for {
        m, _ := client.ReadHoldingRegisters(10765, 1)
        meterKw := float64(signed16(binary.BigEndian.Uint16(m))) * 0.01
        s, _ := client.ReadHoldingRegisters(10671, 1)
        soc := float64(binary.BigEndian.Uint16(s)) * 0.01

        discharge := 0.0
        if meterKw > demandLimit && soc > socReserve {
            discharge = meterKw - demandLimit
        } else if meterKw < 0 {
            discharge = -math.Abs(meterKw) * 0.5
        }
        discharge = math.Max(-10, math.Min(10, discharge))

        client.WriteSingleRegister(11045, toUnsigned(int16(discharge*100)))
        fmt.Printf("Meter:%.1fkW SOC:%.0f%% Bat:%+.1fkW\n", meterKw, soc, discharge)
        time.Sleep(1 * time.Second)
    }
}

const ModbusRTU = require('modbus-serial');
const client = new ModbusRTU();

// RTU: await client.connectRTUBuffered("/dev/ttyUSB0", { baudRate: 9600 });
await client.connectTCP("192.168.1.100", { port: 502 });
client.setID(1);

function signed16(v) { return v >= 32768 ? v - 65536 : v; }
function toUnsigned(v) { return v < 0 ? v + 65536 : v; }

const SOC_MIN = 20.0; // reserve for evening
const RAMP = 0.5;     // max kW step per cycle
let currentSet = 0.0;

// Enable EMS and set SOC reserve
await client.writeRegister(11060, 1);
await client.writeRegister(11108, Math.round(SOC_MIN * 100));

setInterval(async () => {
    const pv = await client.readHoldingRegisters(10087, 1);
    const pvKw = pv.data[0] * 0.01;

    const m = await client.readHoldingRegisters(10765, 1);
    const meterKw = signed16(m.data[0]) * 0.01;

    const s = await client.readHoldingRegisters(10671, 1);
    const soc = s.data[0] * 0.01;

    // Target zero grid exchange; ramp toward target
    const target = -meterKw;
    const delta = Math.max(-RAMP, Math.min(RAMP, target - currentSet));
    currentSet = Math.max(-10, Math.min(10, currentSet + delta));

    // SOC protection
    if (soc <= SOC_MIN && currentSet > 0) currentSet = 0;
    if (soc >= 99.5 && currentSet < 0) currentSet = 0;

    await client.writeRegister(11045, toUnsigned(Math.round(currentSet * 100)));

    const sc = await client.readHoldingRegisters(10810, 1);
    console.log(`PV:${pvKw.toFixed(1)}kW Meter:${meterKw.toFixed(1)}kW `
              + `SOC:${soc.toFixed(0)}% Bat:${currentSet.toFixed(1)}kW SC:${(sc.data[0]*0.1).toFixed(0)}%`);
}, 1000);

using NModbus;
using System.Net.Sockets;

// RTU: var port = new SerialPort("/dev/ttyUSB0", 9600);
//      var master = factory.CreateRtuMaster(port);
var tcp = new TcpClient("192.168.1.100", 502);
var factory = new ModbusFactory();
var master = factory.CreateMaster(tcp);

short Signed16(ushort v) => v >= 32768 ? (short)(v - 65536) : (short)v;
ushort ToUnsigned(int v) => (ushort)(v < 0 ? v + 65536 : v);

const double SocMin = 20.0;
const double Ramp = 0.5;
double currentSet = 0;

master.WriteSingleRegister(1, 11060, 1);                        // EMS on
master.WriteSingleRegister(1, 11108, (ushort)(SocMin * 100));   // SOC reserve

while (true) {
    var pv = master.ReadHoldingRegisters(1, 10087, 1);
    double pvKw = pv[0] * 0.01;

    var m = master.ReadHoldingRegisters(1, 10765, 1);
    double meterKw = Signed16(m[0]) * 0.01;

    var s = master.ReadHoldingRegisters(1, 10671, 1);
    double soc = s[0] * 0.01;

    // Target zero exchange; apply ramp rate
    double target = -meterKw;
    double delta = Math.Clamp(target - currentSet, -Ramp, Ramp);
    currentSet = Math.Clamp(currentSet + delta, -10.0, 10.0);

    if (soc <= SocMin && currentSet > 0) currentSet = 0;  // protect SOC
    if (soc >= 99.5 && currentSet < 0) currentSet = 0;

    master.WriteSingleRegister(1, 11045, ToUnsigned((int)(currentSet * 100)));
    var sc = master.ReadHoldingRegisters(1, 10810, 1);
    Console.WriteLine($"PV:{pvKw:F1}kW Meter:{meterKw:+F1}kW SOC:{soc:F0}% "
                    + $"Bat:{currentSet:+F1}kW SC:{sc[0]*0.1:F0}%");
    Thread.Sleep(1000);
}

package main
import (
    "fmt"; "time"; "math"
    "github.com/goburrow/modbus"
    "encoding/binary"
)

func signed16(v uint16) int16 { return int16(v) }
func toUnsigned(v int16) uint16 { return uint16(v) }

func main() {
    // RTU: handler := modbus.NewRTUClientHandler("/dev/ttyUSB0")
    handler := modbus.NewTCPClientHandler("192.168.1.100:502")
    handler.SlaveId = 1
    handler.Connect()
    defer handler.Close()
    client := modbus.NewClient(handler)

    socMin := 20.0
    ramp := 0.5
    currentSet := 0.0

    client.WriteSingleRegister(11060, 1)                        // EMS on
    client.WriteSingleRegister(11108, uint16(socMin*100))       // SOC reserve

    for {
        pv, _ := client.ReadHoldingRegisters(10087, 1)
        pvKw := float64(binary.BigEndian.Uint16(pv)) * 0.01

        m, _ := client.ReadHoldingRegisters(10765, 1)
        meterKw := float64(signed16(binary.BigEndian.Uint16(m))) * 0.01

        s, _ := client.ReadHoldingRegisters(10671, 1)
        soc := float64(binary.BigEndian.Uint16(s)) * 0.01

        target := -meterKw
        delta := math.Max(-ramp, math.Min(ramp, target-currentSet))
        currentSet = math.Max(-10, math.Min(10, currentSet+delta))
        if soc <= socMin && currentSet > 0 { currentSet = 0 }
        if soc >= 99.5 && currentSet < 0 { currentSet = 0 }

        client.WriteSingleRegister(11045, toUnsigned(int16(currentSet*100)))
        sc, _ := client.ReadHoldingRegisters(10810, 1)
        scRate := float64(binary.BigEndian.Uint16(sc)) * 0.1
        fmt.Printf("PV:%.1fkW Meter:%+.1fkW SOC:%.0f%% Bat:%+.1fkW SC:%.0f%%\n",
            pvKw, meterKw, soc, currentSet, scRate)
        time.Sleep(1 * time.Second)
    }
}

const ModbusRTU = require('modbus-serial');
const client = new ModbusRTU();

async function vppDispatch() {
    await client.connectTCP("192.168.1.100", { port: 502 });
    client.setID(1);

    // Step 1: Safety unlock
    await client.writeRegister(12008, 0x55AA);

    // Step 2: Enable EMS and remote mode
    await client.writeRegister(11060, 1);   // EMS on
    await client.writeRegister(12002, 1);   // Remote mode

    // Step 3: Configure watchdog (proposed P0)
    await client.writeRegister(12010, 1);   // Watchdog enable
    await client.writeRegister(12011, 60);  // Timeout = 60 s

    // Step 4: Dispatch 25.00 kW discharge
    const powerKw = 25.0;
    await client.writeRegister(11045, Math.round(powerKw * 100));

    // Step 5: Verify EMS control active
    const status = await client.readHoldingRegisters(14044, 1);
    const emsActive = status.data[0]; // 1 = active

    // Step 6: Heartbeat loop
    setInterval(async () => {
        await client.writeRegister(12012, 1);
    }, 30000); // Every 30 s
}
vppDispatch().catch(console.error);

using NModbus;
using System.Net.Sockets;

var tcp = new TcpClient("192.168.1.100", 502);
var master = new ModbusFactory().CreateMaster(tcp);
byte unit = 1;

// Step 1: Safety unlock
master.WriteSingleRegister(unit, 12008, 0x55AA);

// Step 2: Enable EMS and remote mode
master.WriteSingleRegister(unit, 11060, 1);  // EMS on
master.WriteSingleRegister(unit, 12002, 1);  // Remote mode

// Step 3: Configure watchdog (proposed P0)
master.WriteSingleRegister(unit, 12010, 1);  // Enable
master.WriteSingleRegister(unit, 12011, 60); // 60 s timeout

// Step 4: Dispatch 25.00 kW discharge
double powerKw = 25.0;
master.WriteSingleRegister(unit, 11045, (ushort)(powerKw * 100));

// Step 5: Verify EMS control
var status = master.ReadHoldingRegisters(unit, 14044, 1);
bool emsActive = status[0] == 1;

// Step 6: Heartbeat loop
while (true) {
    master.WriteSingleRegister(unit, 12012, 1);
    Thread.Sleep(30000); // Every 30 s
}

package main

import (
    "encoding/binary"
    "time"
    "github.com/goburrow/modbus"
)

func main() {
    handler := modbus.NewTCPClientHandler("192.168.1.100:502")
    handler.SlaveId = 1
    handler.Connect()
    defer handler.Close()
    client := modbus.NewClient(handler)

    // Step 1: Safety unlock
    client.WriteSingleRegister(12008, 0x55AA)

    // Step 2: Enable EMS + remote mode
    client.WriteSingleRegister(11060, 1) // EMS on
    client.WriteSingleRegister(12002, 1) // Remote mode

    // Step 3: Watchdog setup (proposed P0)
    client.WriteSingleRegister(12010, 1)  // Enable
    client.WriteSingleRegister(12011, 60) // 60 s timeout

    // Step 4: Dispatch 25.00 kW discharge
    powerVal := uint16(25.0 * 100) // scale 0.01 kW
    client.WriteSingleRegister(11045, powerVal)

    // Step 5: Verify EMS control active
    results, _ := client.ReadHoldingRegisters(14044, 1)
    emsActive := binary.BigEndian.Uint16(results) // 1 = active

    // Step 6: Heartbeat loop
    for {
        client.WriteSingleRegister(12012, 1)
        time.Sleep(30 * time.Second)
    }
    _ = emsActive
}

const ModbusRTU = require('modbus-serial');
const client = new ModbusRTU();

async function emergencyStop() {
    // RTU for minimum latency on safety path
    await client.connectRTUBuffered("/dev/ttyUSB0", { baudRate: 9600 });
    // await client.connectTCP("192.168.1.100", { port: 502 });
    client.setID(1);

    // Step 1: Safety unlock (30 s window)
    await client.writeRegister(12008, 0x55AA);

    // Step 2: Trigger emergency stop (proposed P0)
    await client.writeRegister(12009, 1);

    // Step 3: Verify Standby state
    await new Promise(r => setTimeout(r, 1000));
    const pcs = await client.readHoldingRegisters(14002, 1);
    console.log(`PCS state: ${pcs.data[0]} (1 = Standby)`);

    // Step 4: Read alarm registers for fault codes
    const alarms = await client.readHoldingRegisters(14100, 20);
    const faults = alarms.data
        .map((v, i) => v !== 0 ? i + 14100 : null)
        .filter(v => v !== null);
    console.log("Active fault registers:", faults);

    // Recovery: require human clearance
    // await client.writeRegister(12008, 0x55AA);
    // await client.writeRegister(12000, 1); // Power on
}
emergencyStop().catch(console.error);

using NModbus;
using System.IO.Ports;
// using System.Net.Sockets;

// RTU for minimum latency on safety path
var port = new SerialPort("/dev/ttyUSB0", 9600, Parity.None, 8, StopBits.One);
port.Open();
var master = new ModbusFactory().CreateRtuMaster(port);
// var tcp = new TcpClient("192.168.1.100", 502);
// var master = new ModbusFactory().CreateMaster(tcp);
byte unit = 1;

// Step 1: Safety unlock (30 s expiry window)
master.WriteSingleRegister(unit, 12008, 0x55AA);

// Step 2: Emergency stop (proposed P0)
master.WriteSingleRegister(unit, 12009, 1);

// Step 3: Verify Standby state
Thread.Sleep(1000);
var pcs = master.ReadHoldingRegisters(unit, 14002, 1);
Console.WriteLine($"PCS state: {pcs[0]} (1 = Standby)");

// Step 4: Read alarm registers
var alarms = master.ReadHoldingRegisters(unit, 14100, 20);
for (int i = 0; i < alarms.Length; i++)
    if (alarms[i] != 0)
        Console.WriteLine($"Fault at register {14100 + i}: {alarms[i]}");

// Recovery (after human clearance only):
// master.WriteSingleRegister(unit, 12008, 0x55AA);
// master.WriteSingleRegister(unit, 12000, 1);

package main

import (
    "encoding/binary"
    "fmt"
    "time"
    "github.com/goburrow/modbus"
)

func main() {
    // RTU for minimum latency on safety path
    handler := modbus.NewRTUClientHandler("/dev/ttyUSB0")
    handler.BaudRate = 9600
    handler.SlaveId = 1
    // handler := modbus.NewTCPClientHandler("192.168.1.100:502")
    handler.Connect()
    defer handler.Close()
    client := modbus.NewClient(handler)

    // Step 1: Safety unlock (30 s window)
    client.WriteSingleRegister(12008, 0x55AA)

    // Step 2: Emergency stop (proposed P0)
    client.WriteSingleRegister(12009, 1)

    // Step 3: Verify PCS entered Standby
    time.Sleep(1 * time.Second)
    results, _ := client.ReadHoldingRegisters(14002, 1)
    pcsState := binary.BigEndian.Uint16(results)
    fmt.Printf("PCS state: %d (1 = Standby)\n", pcsState)

    // Step 4: Read alarm registers
    alarms, _ := client.ReadHoldingRegisters(14100, 20)
    for i := 0; i < len(alarms)/2; i++ {
        val := binary.BigEndian.Uint16(alarms[i*2:])
        if val != 0 {
            fmt.Printf("Fault at reg %d: %d\n", 14100+i, val)
        }
    }
    // Recovery: require human clearance before restart
}

const ModbusRTU = require('modbus-serial');
const client = new ModbusRTU();

async function readBatteries() {
    // await client.connectRTUBuffered("/dev/ttyUSB0", { baudRate: 9600 });
    await client.connectTCP("192.168.1.100", { port: 502 });
    client.setID(1);

    const toSigned = (v) => v > 32767 ? v - 65536 : v;
    const readU32 = (d, offset) => (d[offset] << 16) | d[offset + 1];

    // Poll group 3: Battery port 1 (10671-10697)
    const b1 = await client.readHoldingRegisters(10671, 27);
    const bat1 = {
        soc:     b1.data[0] * 0.01,                  // %
        voltage: b1.data[3] * 0.1,                    // V
        current: toSigned(b1.data[4]) * 0.1,          // A (+dis/-chg)
        temp:    b1.data[5] * 0.1,                    // deg C
        chgKwh:  readU32(b1.data, 6) * 0.1,           // kWh
        disKwh:  readU32(b1.data, 8) * 0.1,           // kWh
        cycles:  readU32(b1.data, 12),
        alarm:   readU32(b1.data, 22)
    };

    // Poll group 4: Battery port 2 (10725-10751)
    const b2 = await client.readHoldingRegisters(10725, 27);
    const bat2 = {
        soc:     b2.data[0] * 0.01,
        voltage: b2.data[3] * 0.1,
        current: toSigned(b2.data[4]) * 0.1,
        temp:    b2.data[5] * 0.1,
        alarm:   readU32(b2.data, 22)
    };

    const systemSoc = (bat1.soc + bat2.soc) / 2.0;
    console.log(`Bat1: ${bat1.soc.toFixed(1)}%  Bat2: ${bat2.soc.toFixed(1)}%  System: ${systemSoc.toFixed(1)}%`);
}
readBatteries().catch(console.error);

using NModbus;
using System.Net.Sockets;
// using System.IO.Ports;

var tcp = new TcpClient("192.168.1.100", 502);
var master = new ModbusFactory().CreateMaster(tcp);
// var port = new SerialPort("/dev/ttyUSB0", 9600);
// port.Open();
// var master = new ModbusFactory().CreateRtuMaster(port);
byte unit = 1;

uint ReadU32(ushort[] regs, int offset) =>
    ((uint)regs[offset] << 16) | regs[offset + 1];
short ToSigned(ushort v) => (short)v;

// Poll group 3: Battery port 1 (10671-10697)
var b1 = master.ReadHoldingRegisters(unit, 10671, 27);
double bat1Soc     = b1[0] * 0.01;           // %
double bat1Voltage = b1[3] * 0.1;            // V
double bat1Current = ToSigned(b1[4]) * 0.1;  // A (+dis/-chg)
double bat1Temp    = b1[5] * 0.1;            // deg C
uint bat1Alarm     = ReadU32(b1, 22);

// Poll group 4: Battery port 2 (10725-10751)
var b2 = master.ReadHoldingRegisters(unit, 10725, 27);
double bat2Soc     = b2[0] * 0.01;
double bat2Voltage = b2[3] * 0.1;
double bat2Current = ToSigned(b2[4]) * 0.1;
uint bat2Alarm     = ReadU32(b2, 22);

double systemSoc = (bat1Soc + bat2Soc) / 2.0;
Console.WriteLine($"Bat1: {bat1Soc:F1}%  Bat2: {bat2Soc:F1}%  System: {systemSoc:F1}%");
Console.WriteLine($"Alarms - Bat1: 0x{bat1Alarm:X8}  Bat2: 0x{bat2Alarm:X8}");

package main

import (
    "encoding/binary"
    "fmt"
    "github.com/goburrow/modbus"
)

func main() {
    handler := modbus.NewTCPClientHandler("192.168.1.100:502")
    // handler := modbus.NewRTUClientHandler("/dev/ttyUSB0")
    // handler.BaudRate = 9600
    handler.SlaveId = 1
    handler.Connect()
    defer handler.Close()
    client := modbus.NewClient(handler)

    readU32 := func(data []byte, offset int) uint32 {
        hi := binary.BigEndian.Uint16(data[offset*2:])
        lo := binary.BigEndian.Uint16(data[offset*2+2:])
        return uint32(hi)<<16 | uint32(lo)
    }
    toSigned := func(v uint16) int16 { return int16(v) }

    // Poll group 3: Battery port 1 (10671-10697)
    b1, _ := client.ReadHoldingRegisters(10671, 27)
    bat1Soc := float64(binary.BigEndian.Uint16(b1[0:])) * 0.01
    bat1Cur := float64(toSigned(binary.BigEndian.Uint16(b1[8:]))) * 0.1
    bat1Alarm := readU32(b1, 22)

    // Poll group 4: Battery port 2 (10725-10751)
    b2, _ := client.ReadHoldingRegisters(10725, 27)
    bat2Soc := float64(binary.BigEndian.Uint16(b2[0:])) * 0.01
    bat2Alarm := readU32(b2, 22)

    systemSoc := (bat1Soc + bat2Soc) / 2.0
    fmt.Printf("Bat1: %.1f%%  Bat2: %.1f%%  System: %.1f%%\n", bat1Soc, bat2Soc, systemSoc)
    fmt.Printf("Current Bat1: %.1fA  Alarms: 0x%08X / 0x%08X\n", bat1Cur, bat1Alarm, bat2Alarm)
}

const ModbusRTU = require('modbus-serial');
const client = new ModbusRTU();

const HYSTERESIS_KW = 0.5;   // 500 W deadband
const HOLD_TIME_MS = 60000;  // 60 s hold timer
let lastMode = 2, lastChange = 0;

async function sgReadyLoop() {
    await client.connectRTUBuffered("/dev/ttyUSB0", { baudRate: 9600 });
    // await client.connectTCP("192.168.1.100", { port: 502 });
    client.setID(1);
    await client.writeRegister(11060, 1);  // Enable EMS

    const toSigned = (v) => v > 32767 ? v - 65536 : v;

    setInterval(async () => {
        const pv = await client.readHoldingRegisters(10087, 1);
        const pvKw = pv.data[0] * 0.01;

        const meter = await client.readHoldingRegisters(10765, 1);
        const gridW = toSigned(meter.data[0]) * 10;
        const surplusKw = gridW < 0 ? -gridW / 1000 : 0;

        const bat = await client.readHoldingRegisters(10671, 1);
        const soc = bat.data[0] * 0.01;

        // SG-Ready state machine
        let newMode = lastMode;
        if (surplusKw > 5.0 + HYSTERESIS_KW && soc >= 98) newMode = 4;
        else if (surplusKw > 2.0 + HYSTERESIS_KW && soc > 80) newMode = 3;
        else if (surplusKw < 0.5) newMode = 2;

        const now = Date.now();
        if (newMode !== lastMode && now - lastChange > HOLD_TIME_MS) {
            await client.writeRegister(11355, newMode);
            console.log(`SG-Ready: mode ${lastMode} -> ${newMode} (SOC: ${soc.toFixed(1)}%)`);
            lastMode = newMode;
            lastChange = now;
        }
    }, 10000); // Poll every 10 s
}
sgReadyLoop().catch(console.error);

using NModbus;
using System.IO.Ports;
// using System.Net.Sockets;

var port = new SerialPort("/dev/ttyUSB0", 9600, Parity.None, 8, StopBits.One);
port.Open();
var master = new ModbusFactory().CreateRtuMaster(port);
// var tcp = new TcpClient("192.168.1.100", 502);
// var master = new ModbusFactory().CreateMaster(tcp);
byte unit = 1;

master.WriteSingleRegister(unit, 11060, 1);  // Enable EMS

int lastMode = 2;
DateTime lastChange = DateTime.MinValue;
const double HysteresisKw = 0.5;

while (true) {
    var pv = master.ReadHoldingRegisters(unit, 10087, 1);
    double pvKw = pv[0] * 0.01;

    var meter = master.ReadHoldingRegisters(unit, 10765, 1);
    double gridW = (short)meter[0] * 10.0;
    double surplusKw = gridW < 0 ? -gridW / 1000 : 0;

    var bat = master.ReadHoldingRegisters(unit, 10671, 1);
    double soc = bat[0] * 0.01;

    // SG-Ready state machine with hysteresis
    int newMode = lastMode;
    if (surplusKw > 5.0 + HysteresisKw && soc >= 98) newMode = 4;
    else if (surplusKw > 2.0 + HysteresisKw && soc > 80) newMode = 3;
    else if (surplusKw < 0.5) newMode = 2;

    if (newMode != lastMode && (DateTime.Now - lastChange).TotalSeconds > 60) {
        master.WriteSingleRegister(unit, 11355, (ushort)newMode);
        Console.WriteLine($"SG-Ready: {lastMode} -> {newMode} (SOC: {soc:F1}%)");
        lastMode = newMode;
        lastChange = DateTime.Now;
    }
    Thread.Sleep(10000);
}

package main

import (
    "encoding/binary"
    "fmt"
    "time"
    "github.com/goburrow/modbus"
)

func main() {
    handler := modbus.NewRTUClientHandler("/dev/ttyUSB0")
    handler.BaudRate = 9600
    handler.SlaveId = 1
    // handler := modbus.NewTCPClientHandler("192.168.1.100:502")
    handler.Connect()
    defer handler.Close()
    client := modbus.NewClient(handler)

    client.WriteSingleRegister(11060, 1) // Enable EMS

    lastMode, hysteresisKw := 2, 0.5
    lastChange := time.Now().Add(-2 * time.Minute)

    for {
        pv, _ := client.ReadHoldingRegisters(10087, 1)
        pvKw := float64(binary.BigEndian.Uint16(pv)) * 0.01

        meter, _ := client.ReadHoldingRegisters(10765, 1)
        gridW := float64(int16(binary.BigEndian.Uint16(meter))) * 10
        surplusKw := 0.0
        if gridW < 0 { surplusKw = -gridW / 1000 }

        bat, _ := client.ReadHoldingRegisters(10671, 1)
        soc := float64(binary.BigEndian.Uint16(bat)) * 0.01

        // SG-Ready state machine
        newMode := lastMode
        if surplusKw > 5.0+hysteresisKw && soc >= 98 { newMode = 4
        } else if surplusKw > 2.0+hysteresisKw && soc > 80 { newMode = 3
        } else if surplusKw < 0.5 { newMode = 2 }

        if newMode != lastMode && time.Since(lastChange) > 60*time.Second {
            client.WriteSingleRegister(11355, uint16(newMode))
            fmt.Printf("SG-Ready: %d -> %d (SOC: %.1f%%, PV: %.1fkW)\n",
                lastMode, newMode, soc, pvKw)
            lastMode = newMode
            lastChange = time.Now()
        }
        time.Sleep(10 * time.Second)
    }
}

const ModbusRTU = require('modbus-serial');
const client = new ModbusRTU();

async function commissionVDE4105() {
    await client.connectTCP("192.168.1.100", { port: 502 });
    // await client.connectRTUBuffered("/dev/ttyUSB0", { baudRate: 9600 });
    client.setID(1);

    // 1. Reactive power: Cosfi(P) curve mode
    await client.writeRegister(11300, 3);        // Mode 3 = Cosfi(P)
    await client.writeRegister(11301, 950);      // PF = 0.950

    // 2. Frequency-Watt P(f) droop response
    await client.writeRegister(11330, 1);        // Enable
    await client.writeRegister(11331, 5020);     // Start: 50.20 Hz
    await client.writeRegister(11332, 5180);     // Stop:  51.80 Hz
    await client.writeRegister(11333, 50);       // Droop: 5.0%

    // 3. Power curtailment
    await client.writeRegister(11320, 1);        // Enable WMaxLim
    await client.writeRegister(11321, 700);      // Limit: 70.0%

    // 4. Ramp rate
    await client.writeRegister(11324, 100);      // 10.0 %Pn/s

    // 5. Verify readback
    const verify = async (addr, name, scale) => {
        const r = await client.readHoldingRegisters(addr, 1);
        console.log(`  ${name}: ${(r.data[0] * scale).toFixed(2)}`);
    };
    console.log("VDE-AR-N 4105 readback:");
    await verify(11300, "ReactiveMode", 1);
    await verify(11301, "PowerFactor", 0.001);
    await verify(11331, "HzStart", 0.01);
    await verify(11332, "HzStop", 0.01);
    await verify(11333, "Droop%", 0.1);
    await verify(11321, "WMaxLim%", 0.1);
    await verify(11324, "RampRate", 0.1);
    console.log("Commissioning complete.");
}
commissionVDE4105().catch(console.error);

using NModbus;
using System.Net.Sockets;
// using System.IO.Ports;

var tcp = new TcpClient("192.168.1.100", 502);
var master = new ModbusFactory().CreateMaster(tcp);
// var port = new SerialPort("/dev/ttyUSB0", 9600);
// port.Open();
// var master = new ModbusFactory().CreateRtuMaster(port);
byte unit = 1;

// === VDE-AR-N 4105 Commissioning ===

// 1. Reactive power: Cosfi(P) curve
master.WriteSingleRegister(unit, 11300, 3);       // Mode 3 = Cosfi(P)
master.WriteSingleRegister(unit, 11301, 950);     // PF = 0.950

// 2. Frequency-Watt droop
master.WriteSingleRegister(unit, 11330, 1);       // Enable
master.WriteSingleRegister(unit, 11331, 5020);    // Start: 50.20 Hz
master.WriteSingleRegister(unit, 11332, 5180);    // Stop:  51.80 Hz
master.WriteSingleRegister(unit, 11333, 50);      // Droop: 5.0%

// 3. Power curtailment
master.WriteSingleRegister(unit, 11320, 1);       // Enable
master.WriteSingleRegister(unit, 11321, 700);     // 70.0% of rated

// 4. Ramp rate
master.WriteSingleRegister(unit, 11324, 100);     // 10.0 %Pn/s

// 5. Verify readback
Console.WriteLine("VDE-AR-N 4105 readback:");
var pairs = new (ushort addr, string name, double scale)[] {
    (11300, "ReactiveMode", 1), (11301, "PowerFactor", 0.001),
    (11331, "HzStart", 0.01), (11332, "HzStop", 0.01),
    (11333, "Droop%", 0.1), (11321, "WMaxLim%", 0.1), (11324, "RampRate", 0.1)
};
foreach (var (addr, name, scale) in pairs) {
    var val = master.ReadHoldingRegisters(unit, addr, 1);
    Console.WriteLine($"  {name}: {val[0] * scale:F2}");
}
Console.WriteLine("Commissioning complete.");

package main

import (
    "encoding/binary"
    "fmt"
    "github.com/goburrow/modbus"
)

func main() {
    handler := modbus.NewTCPClientHandler("192.168.1.100:502")
    // handler := modbus.NewRTUClientHandler("/dev/ttyUSB0")
    // handler.BaudRate = 9600
    handler.SlaveId = 1
    handler.Connect()
    defer handler.Close()
    client := modbus.NewClient(handler)

    // 1. Reactive power: Cosfi(P) curve
    client.WriteSingleRegister(11300, 3)      // Mode 3
    client.WriteSingleRegister(11301, 950)    // PF = 0.950

    // 2. Frequency-Watt P(f) droop
    client.WriteSingleRegister(11330, 1)      // Enable
    client.WriteSingleRegister(11331, 5020)   // 50.20 Hz start
    client.WriteSingleRegister(11332, 5180)   // 51.80 Hz stop
    client.WriteSingleRegister(11333, 50)     // 5.0% droop

    // 3. Power curtailment
    client.WriteSingleRegister(11320, 1)      // Enable
    client.WriteSingleRegister(11321, 700)    // 70.0%

    // 4. Ramp rate
    client.WriteSingleRegister(11324, 100)    // 10.0 %Pn/s

    // 5. Verify readback
    type reg struct{ addr uint16; name string; scale float64 }
    regs := []reg{
        {11300, "ReactiveMode", 1}, {11301, "PowerFactor", 0.001},
        {11331, "HzStart", 0.01}, {11332, "HzStop", 0.01},
        {11333, "Droop%", 0.1}, {11321, "WMaxLim%", 0.1},
        {11324, "RampRate", 0.1},
    }
    fmt.Println("VDE-AR-N 4105 readback:")
    for _, r := range regs {
        data, _ := client.ReadHoldingRegisters(r.addr, 1)
        val := float64(binary.BigEndian.Uint16(data)) * r.scale
        fmt.Printf("  %s: %.2f\n", r.name, val)
    }
    fmt.Println("Commissioning complete.")
}