Skip to content

PCS Simulator

pcs_simulator_v3.py is a Modbus TCP simulation server that emulates a PCS (power conversion system) — device_id: PCS1, component PCS, model EPCS105-AM. It serves the same holding registers as the real unit, so the EMS, SCADA and test clients can be exercised without hardware.

Configuration files

Paths are strict — the simulator reads exactly these four files, with no fallbacks — and all of them are re-read when their mtime changes, so edits apply live without a restart. Note that the modbus config sits in emsConfig/, not in simulator_config/.

File Role
emsConfig/pcs_modbus_config.json ip, port, unit_id, log_level
simulator_config/pcs_register.json register map: read_batches, categories (read_only / read_write), modbus and meta blocks, each signal with address, data_type and registers
simulator_config/pcs_register_values.json values to hold — a signal listed here is written verbatim
simulator_config/pcs_sim_par.json generation ranges (min, max, jitter) per signal group, plus the loop period update_interval_sec

Register updates

Every update_interval_sec (default 1) the loop rewrites every signal in the register map:

eng_val = static_vals.get(name, simulate_value(name, sim_params))
  • a signal present in pcs_register_values.json is written as-is — this is what replaced the manual/auto simMode flag of the older simulators. The shipped values file holds the steady-state readings (output_*_voltage_v, output_*_current_a, …);
  • every other signal is generated inside its sim_par range with jitter. *_voltage_v uses line_voltage_v for the line-to-line signals and voltage_v for the rest, plus current_a, frequency_hz, power_kw, temperature_c, pf and derate;
  • mode, flag, enable, sequence and bits signals generate as 0;
  • the *_kwh_hi / *_kwh_lo counters are derived as the high and low halves of one 32-bit energy value (hi = n >> 16, lo = n & 0xFFFF), so a pair always agrees;
  • the simulator is read-only on disk — it never writes a JSON file.

Engineering values are scaled into raw registers as:

Signal Encoding
*frequency*_hz ×100
*_temperature_c ×10
*voltage*_v ×10
*current*_a ×10
*_power_kw / _kvar / _kva ×10
power_factor* ×100
pcs_derating_factor ×4096 (1.0 → 4096)
dsp_software*, cpld_software* raw
modes, commands, counts, time fields int(value)

Because the loop rewrites the whole map every cycle, a Modbus write is transient: it is overwritten on the next cycle unless the same signal is also listed in the values file.

Registers served

Read batch Start register Count
Versions 24576 6
Energy Counters 24592 16
Volt/Current/Powers 24608 29
DC & Status 24656 12
Per-Phase PF 393 3
Setpoints A 3344 73
Controls/Comms/Time 4100 34
On/Off-grid & Parallel 20507 86
Off-grid Settings 259 1
Off-grid Voltage 8743 1
Protection Params 5632 85
Fault Words 5888 8

Signals by category: measurements (31, read-only), powers (24, read-only), energy_counters (16, read-only), versions (6, read-only), setpoints_and_modes (19, read/write), protection_params (21, read/write), controls_comms_time (13, read/write) and faults (9, read-only). Addresses come from the register map, not from the code.

Server

An asynchronous pymodbus TCP server (StartAsyncTcpServer) built on a single shared holding-register bank (single=True), so every unit id addresses the same registers; values are served on function code 3. The unit_id key is read from the modbus config but is not used for routing, so one instance is bound to one PCS endpoint.

Logging

logs/pcs_simulator.log — DEBUG, rotated at midnight with 7 backups. The console handler runs at log_level from the modbus config, and --debug forces DEBUG on the console.

Running

python3 pcs_simulator_v3.py
python3 pcs_simulator_v3.py --debug
python3 pcs_simulator_v3.py --help

Only --debug and --help are handled (scanned from sys.argv; there is no argparse).

Workflow

sequenceDiagram
    participant Op as Operator
    participant Sim as pcs_simulator_v3.py
    participant Cfg as pcs_modbus_config.json
    participant Map as pcs_register.json
    participant Val as pcs_register_values.json
    participant Par as pcs_sim_par.json
    participant HR as Holding registers
    participant Cli as EMS PCS client / SCADA / test client

    Op->>Sim: python3 pcs_simulator_v3.py
    Sim->>Cfg: load ip, port, unit_id, log_level
    Sim->>Map: load read_batches + categories
    Sim->>HR: build register bank (single shared context)
    Sim->>Cli: StartAsyncTcpServer on configured ip:port

    loop every update_interval_sec
        Sim->>Par: mtime check -> reload ranges
        Sim->>Val: mtime check -> reload held values
        Note over Sim,HR: values in the values file are written verbatim, the rest are generated
        Sim->>HR: rewrite every signal (FC03 bank)
    end

    Cli->>Sim: FC03 read of a read batch
    Sim-->>Cli: register values
    Cli->>Sim: FC06/FC16 write to a setpoint
    Note over Sim,HR: held until the next loop cycle rewrites that signal

File tree

flowchart TD
    A["project root/"]
    A --> B["pcs_simulator_v3.py"]
    A --> C["emsConfig/"]
    C --> C1["pcs_modbus_config.json"]
    A --> D["simulator_config/"]
    D --> D1["pcs_register.json"]
    D --> D2["pcs_register_values.json"]
    D --> D3["pcs_sim_par.json"]
    A --> E["logs/"]
    E --> E1["pcs_simulator.log"]
    A --> F["pcsData/"]
    F --> F1["pcs_data_YYYYMMDD_HHMMSS.json  (written by the client, not the simulator)"]

Python Code

pcs_simulator_v3.py
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Sun Aug 10 12:48:41 2025

@author: anura
"""



"""
PCS Modbus TCP Simulator (strict paths, no root fallbacks)

Reads ONLY these files:
  - emsConfig/pcs_modbus_config.json
  - simulator_config/pcs_register.json
  - simulator_config/pcs_register_values.json
  - simulator_config/pcs_sim_par.json

Run:
  python3 pcs_simulator_v3.py
  python3 pcs_simulator_v3.py --debug
  python3 pcs_simulator_v3.py --help
"""

import asyncio
import json
import logging
import os
import random
import sys
import threading
import time
from logging.handlers import TimedRotatingFileHandler
from typing import Dict, Tuple

from pymodbus.datastore import ModbusServerContext, ModbusSlaveContext, ModbusSequentialDataBlock
from pymodbus.device import ModbusDeviceIdentification
from pymodbus.server.async_io import StartAsyncTcpServer

# -------------------------
# Strict paths (NO FALLBACKS)
# -------------------------
MODBUS_CONFIG_PATH = "emsConfig/pcs_modbus_config.json"
REGISTER_FILE      = "simulator_config/pcs_register.json"
VALUES_FILE        = "simulator_config/pcs_register_values.json"
SIM_PARAM_FILE     = "simulator_config/pcs_sim_par.json"

# -------------------------
# Logging
# -------------------------
LOG_DIR = "logs"; os.makedirs(LOG_DIR, exist_ok=True)
LOG_FILE_PATH = os.path.join(LOG_DIR, "pcs_simulator.log")

def setup_logger(level: str) -> logging.Logger:
    lvl = getattr(logging, level.upper(), logging.INFO)
    logger = logging.getLogger("PCSSimulator")
    logger.setLevel(logging.DEBUG)
    fmt = logging.Formatter("%(asctime)s [%(levelname)s] %(message)s")

    ch = logging.StreamHandler(); ch.setLevel(lvl); ch.setFormatter(fmt); logger.addHandler(ch)
    fh = TimedRotatingFileHandler(LOG_FILE_PATH, when="midnight", backupCount=7, encoding="utf-8")
    fh.setLevel(logging.DEBUG); fh.setFormatter(fmt); logger.addHandler(fh)
    return logger

logger = logging.getLogger("PCSSimulator")

def print_help():
    print("""
PCS Modbus TCP Simulator — Help

Options:
  --debug   Force DEBUG logging (overrides config)
  --help    Show this help

Required JSON files (no fallbacks):
  • Modbus   : emsConfig/pcs_modbus_config.json
  • Registers: simulator_config/pcs_register.json
  • Values   : simulator_config/pcs_register_values.json
  • Params   : simulator_config/pcs_sim_par.json
""")

# -------------------------
# I/O helpers
# -------------------------
def _read_json_strict(path: str):
    if not os.path.exists(path):
        raise FileNotFoundError(f"Required file missing: {path}")
    with open(path, "r") as f:
        return json.load(f)

def load_modbus_config() -> dict:
    cfg = _read_json_strict(MODBUS_CONFIG_PATH)
    return {
        "ip": cfg.get("ip", "127.0.0.1"),
        "port": int(cfg.get("port", 1506)),
        "unit_id": int(cfg.get("unit_id", 1)),
        "poll_interval_ms": int(cfg.get("poll_interval_ms", 100)),
        "save_interval_ms": int(cfg.get("save_interval_ms", 2000)),
        "log_level": cfg.get("log_level", "INFO"),
    }

def load_register_map() -> Dict[str, int]:
    data = _read_json_strict(REGISTER_FILE)
    reg_map: Dict[str, int] = {}
    cats = data.get("categories", {})
    for _cat_name, cat in cats.items():
        for name, addr in cat.get("read_only", {}).items():
            reg_map[name] = int(addr)
        for name, addr in cat.get("read_write", {}).items():
            reg_map[name] = int(addr)
    if not reg_map:
        raise ValueError("No registers found in simulator_config/pcs_register.json under categories.*")
    return reg_map

# dynamic values with mtime watch (single strict file)
_VALUES_MTIME = -1.0
_VALUES_CACHE: Dict[str, float] = {}

def _file_mtime(path: str) -> float:
    try: return os.path.getmtime(path)
    except OSError: return -1.0

def get_values() -> Dict[str, float]:
    global _VALUES_MTIME, _VALUES_CACHE
    m = _file_mtime(VALUES_FILE)
    if m == _VALUES_MTIME and _VALUES_CACHE:
        return _VALUES_CACHE
    _VALUES_MTIME = m
    try:
        data = _read_json_strict(VALUES_FILE)
        _VALUES_CACHE = data if isinstance(data, dict) else {}
    except Exception as e:
        logger.warning(f"[WARN] Could not load values: {e}")
        _VALUES_CACHE = {}
    return _VALUES_CACHE

def load_sim_params() -> dict:
    try:
        return _read_json_strict(SIM_PARAM_FILE)
    except Exception:
        # safe defaults if the param file exists but is incomplete
        return {
            "update_interval_sec": 1,
            "voltage_v": {"min": 228.0, "max": 233.0, "jitter": 0.3},
            "line_voltage_v": {"min": 398.0, "max": 403.0, "jitter": 0.4},
            "current_a": {"min": 0.0, "max": 80.0, "jitter": 1.0},
            "frequency_hz": {"min": 49.95, "max": 50.05, "jitter": 0.02},
            "power_kw": {"min": 0.0, "max": 500.0, "jitter": 2.0},
            "temperature_c": {"min": 25.0, "max": 55.0, "jitter": 0.5},
            "pf": {"min": 0.94, "max": 1.00, "jitter": 0.01},
            "derate": {"min": 0.95, "max": 1.00, "jitter": 0.01}
        }

# -------------------------
# Scaling helpers
# -------------------------
def _is(name: str, *parts: str) -> bool:
    return all(p in name for p in parts)

def scale_for_register(name: str, val) -> int:
    intish = {
        "grid_phase_sequence", "working_status_bits", "module_operating_mode",
        "on_off_grid_mode", "single_phase_power_control_enable",
        "module_host_setting", "current_source_parallel_enable",
        "parallel_module_count", "power_command_onoff", "fault_reset_cmd",
        "parameter_curing_cmd", "remodbus_address", "hmi_modbus_address",
        "remodbus_baud_code", "time_year", "time_month", "time_day",
        "time_hour", "time_minute", "time_second"
    }
    if name in intish: return int(val)
    x = float(val)
    if _is(name, "frequency"):                 return int(round(x * 100))   # Hz x100
    if "temperature" in name or name.endswith("_temperature_c"):
                                               return int(round(x * 10))    # °C x10
    if name.endswith("_voltage_v") or _is(name, "voltage"):
                                               return int(round(x * 10))    # V x10
    if name.endswith("_current_a") or _is(name, "current"):
                                               return int(round(x * 10))    # A x10
    if any(s in name for s in ["_power_kw", "_power_kvar", "_power_kva"]):
                                               return int(round(x * 10))    # kW/kvar/kVA x10
    if "power_factor" in name:                 return int(round(x * 100))   # PF x100
    if "pcs_derating_factor" in name:          return int(round(x * 4096))  # 1.0 → 4096
    if any(tok in name for tok in ["dsp_software", "cpld_software"]):
                                               return int(x)                # versions raw
    return int(round(x))

# -------------------------
# Energy helpers
# -------------------------
def split_u32_to_hi_lo(n: int) -> Tuple[int, int]:
    n &= 0xFFFFFFFF
    return (n >> 16) & 0xFFFF, n & 0xFFFF

def try_apply_energy_pairs(static_vals: Dict[str, float], ctx: ModbusServerContext, name2addr: Dict[str, int]):
    pairs = [
        ("dc_charge_energy_kwh", "energy_dc_charge_total_kwh"),
        ("dc_daily_charge_energy_kwh", "energy_dc_daily_charge_kwh"),
        ("dc_discharge_energy_kwh", "energy_dc_discharge_total_kwh"),
        ("dc_daily_discharge_energy_kwh", "energy_dc_daily_discharge_kwh"),
        ("ac_charge_energy_kwh", "energy_ac_charge_total_kwh"),
        ("ac_daily_charge_energy_kwh", "energy_ac_daily_charge_kwh"),
        ("ac_discharge_energy_kwh", "energy_ac_discharge_total_kwh"),
        ("ac_daily_discharge_energy_kwh", "energy_ac_daily_discharge_kwh"),
    ]
    for base, total_key in pairs:
        hi_key = f"{base}_hi"; lo_key = f"{base}_lo"
        if hi_key in name2addr and lo_key in name2addr:
            if hi_key in static_vals and lo_key in static_vals:
                ctx[0].setValues(3, name2addr[hi_key], [int(static_vals[hi_key])])
                ctx[0].setValues(3, name2addr[lo_key], [int(static_vals[lo_key])])
            elif total_key in static_vals:
                total = max(0, int(round(float(static_vals[total_key]))))
                hi, lo = split_u32_to_hi_lo(total)
                ctx[0].setValues(3, name2addr[hi_key], [hi])
                ctx[0].setValues(3, name2addr[lo_key], [lo])

# -------------------------
# Modbus context
# -------------------------
def build_context(name2addr: Dict[str, int]) -> Tuple[ModbusServerContext, int]:
    max_addr = max(name2addr.values(), default=4096) + 4
    hr_data = [0] * max(10000, max_addr + 1)
    context = ModbusServerContext(
        slaves=ModbusSlaveContext(hr=ModbusSequentialDataBlock(0, hr_data)),
        single=True
    )
    return context, max_addr

# -------------------------
# Simulation loop
# -------------------------
def rand_between(mn: float, mx: float, jitter: float) -> float:
    base = random.uniform(mn, mx)
    return base + random.uniform(-jitter, jitter)

def simulate_value(name: str, params: dict) -> float:
    if name.endswith("_temperature_c"):
        p = params["temperature_c"]; return rand_between(p["min"], p["max"], p["jitter"])
    if name.endswith("_voltage_v"):
        if any(k in name for k in ["ab_line", "bc_line", "ca_line", "line_voltage"]):
            p = params["line_voltage_v"]
        else:
            p = params["voltage_v"]
        return rand_between(p["min"], p["max"], p["jitter"])
    if name.endswith("_current_a"):
        p = params["current_a"]; return rand_between(p["min"], p["max"], p["jitter"])
    if "frequency_hz" in name:
        p = params["frequency_hz"]; return rand_between(p["min"], p["max"], p["jitter"])
    if any(s in name for s in ["_power_kw", "_power_kvar", "_power_kva"]):
        p = params["power_kw"]; return max(0.0, rand_between(p["min"], p["max"], p["jitter"]))
    if "power_factor" in name:
        p = params["pf"]; return max(0.0, min(1.0, rand_between(p["min"], p["max"], p["jitter"])))
    if "pcs_derating_factor" in name:
        p = params["derate"]; return max(0.0, min(1.0, rand_between(p["min"], p["max"], p["jitter"])))
    if any(k in name for k in ["mode", "enable", "flag", "sequence", "bits"]):
        return 0
    return 0.0

def update_registers_loop(ctx: ModbusServerContext, name2addr: Dict[str, int]):
    last_params_mtime = -1.0
    update_interval = 1.0
    sim_params = load_sim_params()

    while True:
        try:
            m = _file_mtime(SIM_PARAM_FILE)
            if m != last_params_mtime:
                sim_params = load_sim_params()
                update_interval = float(sim_params.get("update_interval_sec", 1))
                last_params_mtime = m
        except Exception as e:
            logger.warning(f"[WARN] params load: {e}")

        static_vals = get_values()

        # energy pairs first
        try_apply_energy_pairs(static_vals, ctx, name2addr)

        for name, addr in name2addr.items():
            if name.endswith("_kwh_hi") or name.endswith("_kwh_lo"):
                continue
            eng_val = static_vals.get(name, simulate_value(name, sim_params))
            reg_val = scale_for_register(name, eng_val) & 0xFFFF
            ctx[0].setValues(3, addr, [reg_val])
            logger.debug(f"[WRITE] {name} @ {addr} <- {reg_val}")

        time.sleep(update_interval)

# -------------------------
# Main
# -------------------------
async def main():
    if "--help" in sys.argv:
        print_help(); return

    # Validate strict files exist early with helpful errors
    for must in [MODBUS_CONFIG_PATH, REGISTER_FILE, VALUES_FILE, SIM_PARAM_FILE]:
        if not os.path.exists(must):
            raise FileNotFoundError(
                f"Required file not found: {must}\n"
                f">>> Copy your files into simulator_config/ and emsConfig/ exactly as named."
            )

    cfg = load_modbus_config()
    if "--debug" in sys.argv:
        cfg["log_level"] = "DEBUG"

    global logger
    logger = setup_logger(cfg["log_level"])

    name2addr = load_register_map()
    context, _ = build_context(name2addr)

    identity = ModbusDeviceIdentification()
    identity.VendorName = "PCSSim"
    identity.ProductCode = "PCS"
    identity.VendorUrl = "https://example.com"
    identity.ProductName = "PCS Modbus Simulator"
    identity.ModelName = "EPCS105-Sim"
    identity.MajorMinorRevision = "3.0"

    threading.Thread(target=update_registers_loop, args=(context, name2addr), daemon=True).start()

    ip, port = cfg["ip"], int(cfg["port"])
    logger.info(f"[SIM] Starting PCS Modbus TCP Server on {ip}:{port} (strict path mode)…")
    await StartAsyncTcpServer(context=context, identity=identity, address=(ip, port))

if __name__ == "__main__":
    try:
        asyncio.run(main())
    except KeyboardInterrupt:
        print("\n[SIM] Shutdown requested.")

Required Json files

pcs_register.json
{
  "device_id": "PCS1",
  "component_type": "PCS",
  "model": "EPCS105-AM",
  "modbus": {
    "baud": 9600,
    "parity": "N",
    "data_bits": 8,
    "stop_bits": 1,
    "function_codes_supported": [
      3,
      6
    ],
    "max_words_per_read": 16
  },
  "read_batches": [
    {
      "name": "Versions",
      "start_register": 24576,
      "count": 6
    },
    {
      "name": "Energy Counters",
      "start_register": 24592,
      "count": 16
    },
    {
      "name": "Volt/Current/Powers",
      "start_register": 24608,
      "count": 29
    },
    {
      "name": "DC & Status",
      "start_register": 24656,
      "count": 12
    },
    {
      "name": "Per-Phase PF",
      "start_register": 393,
      "count": 3
    },
    {
      "name": "Setpoints A",
      "start_register": 3344,
      "count": 73
    },
    {
      "name": "Controls/Comms/Time",
      "start_register": 4100,
      "count": 34
    },
    {
      "name": "On/Off-grid & Parallel",
      "start_register": 20507,
      "count": 86
    },
    {
      "name": "Off-grid Settings",
      "start_register": 259,
      "count": 1
    },
    {
      "name": "Off-grid Voltage",
      "start_register": 8743,
      "count": 1
    },
    {
      "name": "Protection Params",
      "start_register": 5632,
      "count": 85
    },
    {
      "name": "Fault Words",
      "start_register": 5888,
      "count": 8
    }
  ],
  "categories": {
    "measurements": {
      "read_only": {
        "output_ab_line_voltage_v": 24608,
        "output_bc_line_voltage_v": 24609,
        "output_ca_line_voltage_v": 24610,
        "output_phase_a_voltage_v": 24611,
        "output_phase_b_voltage_v": 24612,
        "output_phase_c_voltage_v": 24613,
        "output_phase_a_current_a": 24614,
        "output_phase_b_current_a": 24615,
        "output_phase_c_current_a": 24616,
        "inductor_phase_a_current_a": 24617,
        "inductor_phase_b_current_a": 24618,
        "inductor_phase_c_current_a": 24619,
        "grid_frequency_hz": 24620,
        "grid_phase_sequence": 24621,
        "pcs_derating_factor": 24622,
        "pcs_derating_flag": 24623,
        "total_bus_voltage_v": 24656,
        "positive_bus_voltage_v": 24657,
        "negative_bus_voltage_v": 24658,
        "battery_voltage_v": 24659,
        "battery_current_a": 24660,
        "dc_power_kw": 24661,
        "dc_total_current_a": 24662,
        "working_status_bits": 24663,
        "igbt_temperature_c": 24664,
        "ambient_temperature_c": 24665,
        "inductor_temperature_c": 24666,
        "current_work_mode": 24667,
        "phase_a_power_factor": 393,
        "phase_b_power_factor": 394,
        "phase_c_power_factor": 395
      }
    },
    "powers": {
      "read_only": {
        "ac_phase_a_active_power_kw": 24624,
        "ac_phase_b_active_power_kw": 24625,
        "ac_phase_c_active_power_kw": 24626,
        "ac_phase_a_apparent_power_kva": 24627,
        "ac_phase_b_apparent_power_kva": 24628,
        "ac_phase_c_apparent_power_kva": 24629,
        "ac_phase_a_reactive_power_kvar": 24630,
        "ac_phase_b_reactive_power_kvar": 24631,
        "ac_phase_c_reactive_power_kvar": 24632,
        "ac_total_active_power_kw": 24633,
        "ac_total_reactive_power_kvar": 24634,
        "ac_total_apparent_power_kva": 24635,
        "ac_power_factor": 24636,
        "ac_charge_energy_kwh_hi": 24600,
        "ac_charge_energy_kwh_lo": 24601,
        "ac_daily_charge_energy_kwh_hi": 24602,
        "ac_daily_charge_energy_kwh_lo": 24603,
        "ac_discharge_energy_kwh_hi": 24604,
        "ac_discharge_energy_kwh_lo": 24605,
        "ac_daily_discharge_energy_kwh_hi": 24606,
        "ac_daily_discharge_energy_kwh_lo": 24607,
        "ac_line_overvoltage_v": 5632,
        "ac_line_undervoltage_v": 5633,
        "ac_overcurrent_a": 5635
      }
    },
    "energy_counters": {
      "read_only": {
        "dc_charge_energy_kwh_hi": 24592,
        "dc_charge_energy_kwh_lo": 24593,
        "dc_daily_charge_energy_kwh_hi": 24594,
        "dc_daily_charge_energy_kwh_lo": 24595,
        "dc_discharge_energy_kwh_hi": 24596,
        "dc_discharge_energy_kwh_lo": 24597,
        "dc_daily_discharge_energy_kwh_hi": 24598,
        "dc_daily_discharge_energy_kwh_lo": 24599,
        "ac_charge_energy_kwh_hi": 24600,
        "ac_charge_energy_kwh_lo": 24601,
        "ac_daily_charge_energy_kwh_hi": 24602,
        "ac_daily_charge_energy_kwh_lo": 24603,
        "ac_discharge_energy_kwh_hi": 24604,
        "ac_discharge_energy_kwh_lo": 24605,
        "ac_daily_discharge_energy_kwh_hi": 24606,
        "ac_daily_discharge_energy_kwh_lo": 24607
      }
    },
    "versions": {
      "read_only": {
        "dsp_software_v": 24576,
        "dsp_software_b": 24577,
        "dsp_software_d": 24578,
        "cpld_software_v": 24579,
        "cpld_software_b": 24580,
        "cpld_software_d": 24581
      }
    },
    "setpoints_and_modes": {
      "read_write": {
        "active_power_set_kw": 3415,
        "reactive_power_set_kvar": 3416,
        "on_off_grid_mode": 20582,
        "module_operating_mode": 20507,
        "single_phase_power_control_enable": 20576,
        "module_host_setting": 20584,
        "current_source_parallel_enable": 20564,
        "parallel_module_count": 20513,
        "offgrid_voltage_setting_v": 8743,
        "offgrid_frequency_setting_hz": 259,
        "phase_a_active_power_set_kw": 678,
        "phase_a_reactive_power_set_kvar": 679,
        "phase_b_active_power_set_kw": 680,
        "phase_b_reactive_power_set_kvar": 681,
        "phase_c_active_power_set_kw": 682,
        "phase_c_reactive_power_set_kvar": 683,
        "insulation_detection_enable": 20592,
        "dc_source_bus_voltage_setting_v": 3350,
        "single_module_bus_voltage_setting_v": 3344
      }
    },
    "protection_params": {
      "read_write": {
        "grid_overfrequency_hz": 5636,
        "grid_underfrequency_hz": 5637,
        "island_overfrequency_hz": 5681,
        "island_underfrequency_hz": 5682,
        "battery_overvoltage_v": 5683,
        "battery_undervoltage_v": 5684,
        "grid_max_charge_discharge_current_a": 5696,
        "bus_overvoltage_v": 5649,
        "bus_undervoltage_v": 5650,
        "dc_overcurrent_a": 5697,
        "ac_line_overvoltage_v": 5632,
        "ac_line_undervoltage_v": 5633,
        "ac_overcurrent_a": 5635,
        "module_overtemp_c": 5664,
        "cc_to_cv_transition_voltage_v": 5699,
        "battery_cv_charge_voltage_v": 5700,
        "cv_max_time_min": 5712,
        "cv_to_float_current_a": 5713,
        "battery_float_voltage_v": 5715,
        "float_to_cc_current_a": 5716,
        "ems_comm_failure_time_s": 5704
      }
    },
    "controls_comms_time": {
      "read_write": {
        "power_command_onoff": 657,
        "fault_reset_cmd": 5120,
        "parameter_curing_cmd": 5125,
        "remodbus_address": 4112,
        "remodbus_baud_code": 4103,
        "hmi_modbus_address": 4113,
        "hmi_modbus_baud_code": 4100,
        "time_year": 4128,
        "time_month": 4129,
        "time_day": 4130,
        "time_hour": 4131,
        "time_minute": 4132,
        "time_second": 4133
      }
    },
    "faults": {
      "read_only": {
        "fault_reset_cmd": 5120,
        "fault_hw_word1": 5888,
        "fault_hw_word2": 5889,
        "fault_grid_word": 5890,
        "fault_bus_word": 5891,
        "fault_ac_cap_word": 5892,
        "fault_system_word": 5893,
        "fault_switch_word": 5894,
        "fault_other_word": 5895
      }
    }
  },
  "meta": {
    "scaling": {
      "voltages_currents": "Registers are scaled x10 (e.g., 400.0 V -> register value 4000).",
      "frequency": "Scaled x100 (e.g., 50.00 Hz -> 5000).",
      "power_kw_kvar_kva": "Scaled x10.",
      "temperatures_c": "Scaled x10.",
      "power_factor": "Scaled x100.",
      "derating_factor": "4096 = 1.0 (e.g., 3686 => 0.9).",
      "status_bits": "See working_status_bits bit-meaning in protocol.",
      "energy_counters": "32-bit via hi/lo 16-bit words, unit kWh."
    }
  }
}
pcs_register_values.json
{
  "output_ab_line_voltage_v": 365.0,
  "output_bc_line_voltage_v": 400.5,
  "output_ca_line_voltage_v": 399.6,
  "output_phase_a_voltage_v": 231.0,
  "output_phase_b_voltage_v": 231.2,
  "output_phase_c_voltage_v": 230.8,
  "output_phase_a_current_a": 45.0,
  "output_phase_b_current_a": 44.7,
  "output_phase_c_current_a": 45.3,
  "inductor_phase_a_current_a": 44.9,
  "inductor_phase_b_current_a": 44.6,
  "inductor_phase_c_current_a": 45.2,
  "grid_frequency_hz": 50.0,
  "grid_phase_sequence": 0,
  "pcs_derating_factor": 1.0,
  "pcs_derating_flag": 0,
  "ac_phase_a_active_power_kw": 15.2,
  "ac_phase_b_active_power_kw": 15.1,
  "ac_phase_c_active_power_kw": 15.0,
  "ac_phase_a_apparent_power_kva": 16.2,
  "ac_phase_b_apparent_power_kva": 16.1,
  "ac_phase_c_apparent_power_kva": 16.0,
  "ac_phase_a_reactive_power_kvar": 2.0,
  "ac_phase_b_reactive_power_kvar": 1.9,
  "ac_phase_c_reactive_power_kvar": 2.1,
  "ac_total_active_power_kw": 45.3,
  "ac_total_reactive_power_kvar": 6.0,
  "ac_total_apparent_power_kva": 48.3,
  "ac_power_factor": 0.94,
  "total_bus_voltage_v": 750.0,
  "positive_bus_voltage_v": 375.2,
  "negative_bus_voltage_v": 374.8,
  "battery_voltage_v": 732.5,
  "battery_current_a": 62.0,
  "dc_power_kw": 45.0,
  "dc_total_current_a": 62.0,
  "working_status_bits": 9,
  "igbt_temperature_c": 42.5,
  "ambient_temperature_c": 27.0,
  "inductor_temperature_c": 39.2,
  "current_work_mode": 1,
  "dsp_software_v": 5130,
  "dsp_software_b": 0,
  "dsp_software_d": 0,
  "cpld_software_v": 100,
  "cpld_software_b": 0,
  "cpld_software_d": 0,
  "phase_a_power_factor": 0.95,
  "phase_b_power_factor": 0.94,
  "phase_c_power_factor": 0.95,
  "energy_dc_charge_total_kwh": 1250.0,
  "energy_dc_discharge_total_kwh": 1195.0,
  "energy_ac_charge_total_kwh": 1220.0,
  "energy_ac_discharge_total_kwh": 1180.0,
  "active_power_set_kw": 45.0,
  "reactive_power_set_kvar": 6.0,
  "on_off_grid_mode": 0,
  "module_operating_mode": 1,
  "single_phase_power_control_enable": 0,
  "module_host_setting": 0,
  "current_source_parallel_enable": 0,
  "parallel_module_count": 1,
  "offgrid_voltage_setting_v": 400.0,
  "offgrid_frequency_setting_hz": 50.0,
  "phase_a_active_power_set_kw": 0.0,
  "phase_a_reactive_power_set_kvar": 0.0,
  "phase_b_active_power_set_kw": 0.0,
  "phase_b_reactive_power_set_kvar": 0.0,
  "phase_c_active_power_set_kw": 0.0,
  "phase_c_reactive_power_set_kvar": 0.0,
  "insulation_detection_enable": 0,
  "dc_source_bus_voltage_setting_v": 750.0,
  "single_module_bus_voltage_setting_v": 750.0,
  "grid_overfrequency_hz": 51.5,
  "grid_underfrequency_hz": 47.5,
  "island_overfrequency_hz": 51.5,
  "island_underfrequency_hz": 47.5,
  "battery_overvoltage_v": 950.0,
  "battery_undervoltage_v": 615.0,
  "grid_max_charge_discharge_current_a": 170.0,
  "bus_overvoltage_v": 950.0,
  "bus_undervoltage_v": 615.0,
  "dc_overcurrent_a": 180.0,
  "ac_line_overvoltage_v": 460.0,
  "ac_line_undervoltage_v": 320.0,
  "ac_overcurrent_a": 170.0,
  "module_overtemp_c": 85.0,
  "cc_to_cv_transition_voltage_v": 820.0,
  "battery_cv_charge_voltage_v": 840.0,
  "cv_max_time_min": 120.0,
  "cv_to_float_current_a": 10.0,
  "battery_float_voltage_v": 820.0,
  "float_to_cc_current_a": 20.0,
  "power_command_onoff": 1,
  "fault_reset_cmd": 0,
  "parameter_curing_cmd": 0,
  "remodbus_address": 1,
  "remodbus_baud_code": 96,
  "hmi_modbus_address": 1,
  "hmi_modbus_baud_code": 96,
  "time_year": 2025,
  "time_month": 8,
  "time_day": 10,
  "time_hour": 12,
  "time_minute": 0,
  "time_second": 0,
  "fault_hw_word1": 0,
  "fault_hw_word2": 0,
  "fault_grid_word": 0,
  "fault_bus_word": 0,
  "fault_ac_cap_word": 0,
  "fault_system_word": 0,
  "fault_switch_word": 0,
  "fault_other_word": 0
}
pcs_sim_par.json
{
  "update_interval_sec": 1,
  "voltage_v": { "min": 228.0, "max": 233.0, "jitter": 0.3 },
  "line_voltage_v": { "min": 398.0, "max": 403.0, "jitter": 0.4 },
  "current_a": { "min": 0.0, "max": 160.0, "jitter": 1.5 },
  "frequency_hz": { "min": 49.95, "max": 50.05, "jitter": 0.02 },
  "power_kw": { "min": 0.0, "max": 105.0, "jitter": 2.0 },
  "temperature_c": { "min": 25.0, "max": 55.0, "jitter": 0.5 },
  "pf": { "min": 0.94, "max": 1.00, "jitter": 0.01 },
  "derate": { "min": 0.95, "max": 1.00, "jitter": 0.01 }
}
pcs_modbus_config.json
{
  "ip": "127.0.0.1",
  "port": 1506,
  "unit_id": 1,
  "poll_interval_ms": 1000,
  "save_interval_ms": 5000,
  "log_level": "INFO"
}

Sample data emitted downstream

The client batches what it reads from this simulator into pcsData/, one array of pcs_* records per flush (per-unit runs also write pcs1_data_*.json and keep per-unit folders pcs1/, pcs2/, pcs3/):

pcs_data_20251224_221014.json
[
  {
    "timestamp": 1766610611625,
    "pcs_timestamp": 1766610611625,
    "pcs_active_energy_delivered_minus_received_kwh": 0.0,
    "pcs_reactive_energy_delivered_kvarh": 0.0,
    "pcs_reactive_energy_received_kvarh": 0.0,
    "pcs_reactive_energy_delivered_minus_received_kvarh": 0.0,
    "pcs_apparent_energy_delivered_kvah": 0.0,
    "pcs_apparent_energy_received_kvah": 0.0,
    "pcs_apparent_energy_delivered_minus_received_kvah": 0.0,
    "pcs_current_a_a": 0.0,
    "pcs_current_b_a": 0.0,
    "pcs_current_c_a": 0.0,
    "pcs_current_n_a": 0.0,
    "pcs_current_avg_a": 0.0,
    "pcs_voltage_ab_v": 44.69999694824219,
    "pcs_voltage_bc_v": 0.0,
    "pcs_voltage_ca_v": 0.0,
    "pcs_voltage_ll_avg_v": 0.0,
    "pcs_voltage_an_v": 0.0,
    "pcs_voltage_bn_v": 0.0,
    "pcs_voltage_cn_v": 0.0,
    "pcs_voltage_ln_avg_v": 0.0,
    "pcs_active_power_total_kw": 0.0,
    "pcs_reactive_power_total_kvar": 0.0,
    "pcs_apparent_power_total_kva": 0.0,
    "pcs_active_power_a_kw": 0.0,
    "pcs_active_power_b_kw": 0.0,
    "pcs_active_power_c_kw": 0.0,
    "pcs_reactive_power_a_kvar": 0.0,
    "pcs_reactive_power_b_kvar": 0.0,
    "pcs_reactive_power_c_kvar": 0.0,
    "pcs_apparent_power_a_kva": 0.0,
    "pcs_apparent_power_b_kva": 0.0,
    "pcs_apparent_power_c_kva": 0.0,
    "pcs_pf_total": 0.0,
    "pcs_pf_a": 0.0,
    "pcs_pf_b": 0.0,
    "pcs_pf_c": 0.0,
    "pcs_frequency_hz": 50.20000076293945,
    "pcs_digital_input_status_validity_base": 0,
    "pcs_digital_input_status_validity_base_hex": "0x00000000",
    "pcs_alarm_code": 0,
    "pcs_alarm_code_hex": "0x00000000",
    "pcs_setpoint_status_validity": 0,
    "pcs_setpoint_status_validity_hex": "0x00000000",
    "pcs_digital_input_status_validity_slot_a": 0,
    "pcs_digital_input_status_validity_slot_a_hex": "0x00000000",
    "pcs_digital_input_status_validity_slot_b": 0,
    "pcs_digital_input_status_validity_slot_b_hex": "0x00000000",
    "pcs_digital_input_status_validity_slot_c": 0,
    "pcs_digital_input_status_validity_slot_c_hex": "0x00000000",
    "pcs_digital_input_status_validity_slot_d": 0,
    "pcs_digital_input_status_validity_slot_d_hex": "0x00000000",
    "pcs_digital_output_status_validity_slot_a": 0,
    "pcs_digital_output_status_validity_slot_a_hex": "0x00000000",
    "pcs_digital_output_status_validity_slot_b": 0,
    "pcs_digital_output_status_validity_slot_b_hex": "0x00000000",
    "pcs_digital_output_status_validity_slot_c": 0,
    "pcs_digital_output_status_validity_slot_c_hex": "0x00000000",
    "pcs_digital_output_status_validity_slot_d": 0,
    "pcs_digital_output_status_validity_slot_d_hex": "0x00000000",
    "pcs_current_disturbance": 0,
    "pcs_voltage_disturbance": 0
  },
  {
    "timestamp": 1766610614669,
    "pcs_timestamp": 1766610614669,
    "pcs_active_energy_delivered_minus_received_kwh": 0.0,
    "pcs_reactive_energy_delivered_kvarh": 0.0,
    "pcs_reactive_energy_received_kvarh": 0.0,
    "pcs_reactive_energy_delivered_minus_received_kvarh": 0.0,
    "pcs_apparent_energy_delivered_kvah": 0.0,
    "pcs_apparent_energy_received_kvah": 0.0,
    "pcs_apparent_energy_delivered_minus_received_kvah": 0.0,
    "pcs_current_a_a": 0.0,
    "pcs_current_b_a": 0.0,
    "pcs_current_c_a": 0.0,
    "pcs_current_n_a": 0.0,
    "pcs_current_avg_a": 0.0,
    "pcs_voltage_ab_v": 44.69999694824219,
    "pcs_voltage_bc_v": 0.0,
    "pcs_voltage_ca_v": 0.0,
    "pcs_voltage_ll_avg_v": 0.0,
    "pcs_voltage_an_v": 0.0,
    "pcs_voltage_bn_v": 0.0,
    "pcs_voltage_cn_v": 0.0,
    "pcs_voltage_ln_avg_v": 0.0,
    "pcs_active_power_total_kw": 0.0,
    "pcs_reactive_power_total_kvar": 0.0,
    "pcs_apparent_power_total_kva": 0.0,
    "pcs_active_power_a_kw": 0.0,
    "pcs_active_power_b_kw": 0.0,
    "pcs_active_power_c_kw": 0.0,
    "pcs_reactive_power_a_kvar": 0.0,
    "pcs_reactive_power_b_kvar": 0.0,
    "pcs_reactive_power_c_kvar": 0.0,
    "pcs_apparent_power_a_kva": 0.0,
    "pcs_apparent_power_b_kva": 0.0,
    "pcs_apparent_power_c_kva": 0.0,
    "pcs_pf_total": 0.0,
    "pcs_pf_a": 0.0,
    "pcs_pf_b": 0.0,
    "pcs_pf_c": 0.0,
    "pcs_frequency_hz": 50.20000076293945,
    "pcs_digital_input_status_validity_base": 0,
    "pcs_digital_input_status_validity_base_hex": "0x00000000",
    "pcs_alarm_code": 0,
    "pcs_alarm_code_hex": "0x00000000",
    "pcs_setpoint_status_validity": 0,
    "pcs_setpoint_status_validity_hex": "0x00000000",
    "pcs_digital_input_status_validity_slot_a": 0,
    "pcs_digital_input_status_validity_slot_a_hex": "0x00000000",
    "pcs_digital_input_status_validity_slot_b": 0,
    "pcs_digital_input_status_validity_slot_b_hex": "0x00000000",
    "pcs_digital_input_status_validity_slot_c": 0,
    "pcs_digital_input_status_validity_slot_c_hex": "0x00000000",
    "pcs_digital_input_status_validity_slot_d": 0,
    "pcs_digital_input_status_validity_slot_d_hex": "0x00000000",
    "pcs_digital_output_status_validity_slot_a": 0,
    "pcs_digital_output_status_validity_slot_a_hex": "0x00000000",
    "pcs_digital_output_status_validity_slot_b": 0,
    "pcs_digital_output_status_validity_slot_b_hex": "0x00000000",
    "pcs_digital_output_status_validity_slot_c": 0,
    "pcs_digital_output_status_validity_slot_c_hex": "0x00000000",
    "pcs_digital_output_status_validity_slot_d": 0,
    "pcs_digital_output_status_validity_slot_d_hex": "0x00000000",
    "pcs_current_disturbance": 0,
    "pcs_voltage_disturbance": 0
  }
]