Skip to content

Solar Meter Simulator

solarMeter_simulator_v6.py is a Modbus TCP simulation server that emulates a solar energy meter — device_id: solarEnergyMeter1, component solarEnergyMeter, model Schneider PM8000. It serves the same holding registers as the real meter, so EMS, SCADA and test clients can be exercised without the 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.

File Role
simulator_config/solarMeter_modbus_config.json ip, port, unit_id, log_level
simulator_config/solarMeter_register.json register map: read_batches plus categories (read_only / read_write), each signal with address, data_type and registers
simulator_config/solarMeter_register_values.json values to hold — a signal listed here is written verbatim
simulator_config/solarMeter_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 solarMeter_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 (voltage_ab_v, voltage_bc_v, voltage_ca_v, voltage_an_v, current_a_a, …);
  • every other signal is generated inside its sim_par range with jitter (voltage_ll_v, voltage_ln_v, current_a, frequency_hz, power_kw, kvar, kva, pf);
  • bitmap_on_prob drives the probability that a status/bitmap word has bits set;
  • values are encoded as declared by the register map: FLOAT32, INT32U and BITMAP32 span two registers, with endianness taken from the batch (read_batches[].endianness, big by default);
  • the simulator is read-only on disk — it never writes a JSON file.

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
Energies 2700 50
Currents 3000 20
Voltages 3020 20
Power & PF & Freq 3054 120

Signals: energies (12), currents (5), voltages (8), power (12), power factor (4), frequency (1), alarms (13). Addresses come from the register map, not from the code. The power signals here are named power_kw / reactive_power_total_kvar / apparent_power_total_kva (the FFR meter uses the active_power_* spelling for the same registers).

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.

Logging

logs/solarMeter_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 solarMeter_simulator_v6.py
python3 solarMeter_simulator_v6.py --debug
python3 solarMeter_simulator_v6.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 solarMeter_simulator_v6.py
    participant Cfg as solarMeter_modbus_config.json
    participant Map as solarMeter_register.json
    participant Val as solarMeter_register_values.json
    participant Par as solarMeter_sim_par.json
    participant HR as Holding registers
    participant Cli as EMS / SCADA / test client

    Op->>Sim: python3 solarMeter_simulator_v6.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

File tree

flowchart TD
    A["project root/"]
    A --> B["solarMeter_simulator_v6.py"]
    A --> C["simulator_config/"]
    C --> C1["solarMeter_modbus_config.json"]
    C --> C2["solarMeter_register.json"]
    C --> C3["solarMeter_register_values.json"]
    C --> C4["solarMeter_sim_par.json"]
    A --> D["logs/"]
    D --> D1["solarMeter_simulator.log"]
    A --> E["solarMeterData/"]
    E --> E1["solar_data_YYYYMMDD_HHMMSS.json  (written by the client, not the simulator)"]

Python Code

solarMeter_simulator_v6.py
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Sun Aug 10 16:13:59 2025

@author: anura
"""

"""
solarMeter Meter Modbus TCP Simulator (v6, PM8000-style, strict paths)

Reads ONLY these files:
  - emsConfig/solarMeter_modbus_config.json
  - simulator_config/solarMeter_register.json
  - simulator_config/solarMeter_register_values.json
  - simulator_config/solarMeter_sim_par.json

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

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

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 = "simulator_config/solarMeter_modbus_config.json"
REGISTER_FILE      = "simulator_config/solarMeter_register.json"
VALUES_FILE        = "simulator_config/solarMeter_register_values.json"
SIM_PARAM_FILE     = "simulator_config/solarMeter_sim_par.json"

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

def setup_logger(level: str) -> logging.Logger:
    lvl = getattr(logging, level.upper(), logging.INFO)
    logger = logging.getLogger("solarMeterSimulator")
    logger.setLevel(logging.DEBUG)

    fmt = logging.Formatter("%(asctime)s [%(levelname)s] %(message)s")

    ch = logging.StreamHandler()
    ch.setLevel(lvl)
    ch.setFormatter(fmt)
    if not logger.handlers:
        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("solarMeterSimulator")

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

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

Required JSON files (no fallbacks):
  • Modbus   : emsConfig/solarMeter_modbus_config.json
  • Registers: simulator_config/solarMeter_register.json
  • Values   : simulator_config/solarMeter_register_values.json
  • Params   : simulator_config/solarMeter_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", 1507)),  # default solarMeter port; change as needed
        "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"),
    }

# Structure for each mapped point
# {
#   "name": "<signal_name>",
#   "address": <int>,
#   "data_type": "FLOAT32" | "INT32U" | "BITMAP32",
#   "registers": 2,  # always 2 for these types
# }
def load_register_map() -> Tuple[Dict[str, Dict[str, Any]], str]:
    """Return (name->meta, default_endianness) from solarMeter_register.json."""
    data = _read_json_strict(REGISTER_FILE)

    default_endianness = "big"
    batches = data.get("read_batches", [])
    if batches:
        default_endianness = (batches[0].get("endianness") or "big").lower()

    cats = data.get("categories", {})
    name2meta: Dict[str, Dict[str, Any]] = {}
    for _cat_name, cat in cats.items():
        for section in ("read_only", "read_write"):
            sec = cat.get(section, {})
            for name, meta in sec.items():
                if not isinstance(meta, dict):
                    continue
                addr = int(meta.get("address"))
                dt   = (meta.get("data_type") or "FLOAT32").upper()
                regs = int(meta.get("registers") or (2 if dt in ("FLOAT32", "INT32U", "BITMAP32") else 1))
                name2meta[name] = {
                    "address": addr,
                    "data_type": dt,
                    "registers": regs,
                }
    if not name2meta:
        raise ValueError("No usable registers found in simulator_config/solarMeter_register.json under categories.*")

    return name2meta, default_endianness

# 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 for PV behavior
        return {
            "update_interval_sec": 1,
            "voltage_ll_v": {"min": 398.0, "max": 403.0, "jitter": 0.4},
            "voltage_ln_v": {"min": 229.0, "max": 232.0, "jitter": 0.3},
            "current_a":    {"min": 0.0,   "max": 120.0, "jitter": 1.5},
            "frequency_hz": {"min": 49.95, "max": 50.05, "jitter": 0.02},
            "power_kw":     {"min": 0.0,   "max": 250.0, "jitter": 3.0},
            "kvar":         {"min": -50.0, "max": 50.0,  "jitter": 1.0},
            "kva":          {"min": 0.0,   "max": 255.0, "jitter": 3.0},
            "pf":           {"min": 0.95,  "max": 1.00,  "jitter": 0.01},
            "bitmap_on_prob": 0.01
        }

# -------------------------
# Packing helpers (two 16-bit words per value)
# -------------------------
def pack_float32_to_words(val: float, endianness: str) -> Tuple[int, int]:
    bs = struct.pack(">f", float(val)) if endianness == "big" else struct.pack("<f", float(val))
    hi = (bs[0] << 8) | bs[1]
    lo = (bs[2] << 8) | bs[3]
    return hi & 0xFFFF, lo & 0xFFFF

def pack_uint32_to_words(val: int, endianness: str) -> Tuple[int, int]:
    v = int(val) & 0xFFFFFFFF
    if endianness == "big":
        hi = (v >> 16) & 0xFFFF
        lo = v & 0xFFFF
    else:
        lo = (v >> 16) & 0xFFFF
        hi = v & 0xFFFF
    return hi, lo

# -------------------------
# Modbus context
# -------------------------
def build_context(name2meta: Dict[str, Dict[str, Any]]) -> Tuple[ModbusServerContext, int]:
    max_addr = 0
    for meta in name2meta.values():
        end = int(meta["address"]) + int(meta["registers"])
        if end > max_addr:
            max_addr = end
    hr_data = [0] * max(14000, max_addr + 4)
    context = ModbusServerContext(
        slaves=ModbusSlaveContext(hr=ModbusSequentialDataBlock(0, hr_data)),
        single=True
    )
    return context, max_addr

# -------------------------
# Simulation logic
# -------------------------
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 | int:
    nm = name.lower()
    if nm.startswith("voltage_ab_") or nm.startswith("voltage_bc_") or nm.startswith("voltage_ca_") or "voltage_ll_avg" in nm:
        p = params["voltage_ll_v"]; return rand_between(p["min"], p["max"], p["jitter"])
    if nm.startswith("voltage_a") or nm.startswith("voltage_b") or nm.startswith("voltage_c") or "voltage_ln_avg" in nm:
        p = params["voltage_ln_v"]; return rand_between(p["min"], p["max"], p["jitter"])
    if nm.startswith("current_") or "current_avg" in nm:
        p = params["current_a"]; return max(0.0, rand_between(p["min"], p["max"], p["jitter"]))
    if "frequency_hz" in nm:
        p = params["frequency_hz"]; return rand_between(p["min"], p["max"], p["jitter"])
    if "active_power" in nm:
        p = params["power_kw"]; return max(0.0, rand_between(p["min"], p["max"], p["jitter"]))
    if "reactive_power" in nm:
        p = params["kvar"]; return rand_between(p["min"], p["max"], p["jitter"])
    if "apparent_power" in nm:
        p = params["kva"]; return max(0.0, rand_between(p["min"], p["max"], p["jitter"]))
    if nm.startswith("pf_") or nm == "pf_total":
        p = params["pf"]; return max(0.0, min(1.0, rand_between(p["min"], p["max"], p["jitter"])))
    if "disturbance" in nm or "validity" in nm:
        prob = float(params.get("bitmap_on_prob", 0.01))
        bits = 0
        for b in range(32):
            if random.random() < prob:
                bits |= (1 << b)
        return bits
    return 0.0

def update_registers_loop(ctx: ModbusServerContext, name2meta: Dict[str, Dict[str, Any]], default_endianness: str):
    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()

        for name, meta in name2meta.items():
            addr = int(meta["address"])
            dtype = meta["data_type"].upper()
            regs  = int(meta["registers"])

            eng_val = static_vals.get(name, simulate_value(name, sim_params))

            if dtype == "FLOAT32":
                hi, lo = pack_float32_to_words(float(eng_val), default_endianness)
            elif dtype in ("INT32U", "BITMAP32"):
                hi, lo = pack_uint32_to_words(int(eng_val), default_endianness)
            else:
                hi, lo = pack_float32_to_words(float(eng_val), default_endianness)

            words = [hi & 0xFFFF, lo & 0xFFFF]
            if regs < 2:
                words = [words[0]]
            ctx[0].setValues(3, addr, words)
            logger.debug(f"[WRITE] {name} @{addr} ({dtype}/{regs}) <- {words}")

        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"])

    name2meta, endianness = load_register_map()
    context, _ = build_context(name2meta)

    identity = ModbusDeviceIdentification()
    identity.VendorName = "solarMeterSim"
    identity.ProductCode = "solarMeter"
    identity.VendorUrl = "https://example.com"
    identity.ProductName = "solarMeter Modbus Simulator"
    identity.ModelName = "PM8000-Sim"
    identity.MajorMinorRevision = "6.0"

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

    ip, port = cfg["ip"], int(cfg["port"])
    logger.info(f"[SIM] Starting solarMeter Modbus TCP Server on {ip}:{port} (strict path mode, endianness={endianness})…")
    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

solarMeter_register.json
{
  "device_id": "solarEnergyMeter1",
  "component_type": "solarEnergyMeter",
  "model": "Schneider PM8000",
  "read_batches": [
    {
      "name": "Energies",
      "start_register": 2700,
      "count": 50,
      "word_size": 16,
      "endianness": "big"
    },
    {
      "name": "Currents",
      "start_register": 3000,
      "count": 20,
      "word_size": 16,
      "endianness": "big"
    },
    {
      "name": "Voltages",
      "start_register": 3020,
      "count": 20,
      "word_size": 16,
      "endianness": "big"
    },
    {
      "name": "Power & PF & Freq",
      "start_register": 3054,
      "count": 120,
      "word_size": 16,
      "endianness": "big"
    }
  ],
  "categories": {
    "energies": {
      "read_only": {
        "active_energy_delivered_kwh": null,
        "active_energy_received_kwh": null,
        "active_energy_delivered_plus_received_kwh": null,
        "active_energy_delivered_minus_received_kwh": {
          "address": 2706,
          "data_type": "FLOAT32",
          "registers": 2
        },
        "reactive_energy_delivered_kvarh": {
          "address": 2708,
          "data_type": "FLOAT32",
          "registers": 2
        },
        "reactive_energy_received_kvarh": {
          "address": 2710,
          "data_type": "FLOAT32",
          "registers": 2
        },
        "reactive_energy_delivered_plus_received_kvarh": null,
        "reactive_energy_delivered_minus_received_kvarh": {
          "address": 2714,
          "data_type": "FLOAT32",
          "registers": 2
        },
        "apparent_energy_delivered_kvah": {
          "address": 2716,
          "data_type": "FLOAT32",
          "registers": 2
        },
        "apparent_energy_received_kvah": {
          "address": 2718,
          "data_type": "FLOAT32",
          "registers": 2
        },
        "apparent_energy_delivered_plus_received_kvah": null,
        "apparent_energy_delivered_minus_received_kvah": {
          "address": 2722,
          "data_type": "FLOAT32",
          "registers": 2
        }
      }
    },
    "currents": {
      "read_only": {
        "current_a_a": {
          "address": 3000,
          "data_type": "FLOAT32",
          "registers": 2
        },
        "current_b_a": {
          "address": 3002,
          "data_type": "FLOAT32",
          "registers": 2
        },
        "current_c_a": {
          "address": 3004,
          "data_type": "FLOAT32",
          "registers": 2
        },
        "current_n_a": {
          "address": 3006,
          "data_type": "FLOAT32",
          "registers": 2
        },
        "current_avg_a": {
          "address": 3010,
          "data_type": "FLOAT32",
          "registers": 2
        }
      }
    },
    "voltages": {
      "read_only": {
        "voltage_ab_v": {
          "address": 3020,
          "data_type": "FLOAT32",
          "registers": 2
        },
        "voltage_bc_v": {
          "address": 3022,
          "data_type": "FLOAT32",
          "registers": 2
        },
        "voltage_ca_v": {
          "address": 3024,
          "data_type": "FLOAT32",
          "registers": 2
        },
        "voltage_ll_avg_v": {
          "address": 3026,
          "data_type": "FLOAT32",
          "registers": 2
        },
        "voltage_an_v": {
          "address": 3028,
          "data_type": "FLOAT32",
          "registers": 2
        },
        "voltage_bn_v": {
          "address": 3030,
          "data_type": "FLOAT32",
          "registers": 2
        },
        "voltage_cn_v": {
          "address": 3032,
          "data_type": "FLOAT32",
          "registers": 2
        },
        "voltage_ln_avg_v": {
          "address": 3036,
          "data_type": "FLOAT32",
          "registers": 2
        }
      }
    },
    "power": {
      "read_only": {
        "power_kw": {
          "address": 3060,
          "data_type": "FLOAT32",
          "registers": 2
        },
        "reactive_power_total_kvar": {
          "address": 3068,
          "data_type": "FLOAT32",
          "registers": 2
        },
        "apparent_power_total_kva": {
          "address": 3076,
          "data_type": "FLOAT32",
          "registers": 2
        },
        "active_power_a_kw": {
          "address": 3054,
          "data_type": "FLOAT32",
          "registers": 2
        },
        "active_power_b_kw": {
          "address": 3056,
          "data_type": "FLOAT32",
          "registers": 2
        },
        "active_power_c_kw": {
          "address": 3058,
          "data_type": "FLOAT32",
          "registers": 2
        },
        "reactive_power_a_kvar": {
          "address": 3062,
          "data_type": "FLOAT32",
          "registers": 2
        },
        "reactive_power_b_kvar": {
          "address": 3064,
          "data_type": "FLOAT32",
          "registers": 2
        },
        "reactive_power_c_kvar": {
          "address": 3066,
          "data_type": "FLOAT32",
          "registers": 2
        },
        "apparent_power_a_kva": {
          "address": 3070,
          "data_type": "FLOAT32",
          "registers": 2
        },
        "apparent_power_b_kva": {
          "address": 3072,
          "data_type": "FLOAT32",
          "registers": 2
        },
        "apparent_power_c_kva": {
          "address": 3074,
          "data_type": "FLOAT32",
          "registers": 2
        }
      }
    },
    "power_factor": {
      "read_only": {
        "pf_total": {
          "address": 3150,
          "data_type": "FLOAT32",
          "registers": 2
        },
        "pf_a": {
          "address": 3144,
          "data_type": "FLOAT32",
          "registers": 2
        },
        "pf_b": {
          "address": 3146,
          "data_type": "FLOAT32",
          "registers": 2
        },
        "pf_c": {
          "address": 3148,
          "data_type": "FLOAT32",
          "registers": 2
        }
      }
    },
    "frequency": {
      "read_only": {
        "frequency_hz": {
          "address": 3110,
          "data_type": "FLOAT32",
          "registers": 2
        }
      }
    },
    "alarms": {
      "read_only": {
        "digital_input_status_validity_base": {
          "address": 2400,
          "data_type": "BITMAP32",
          "registers": 2
        },
        "digital_output_status_validity_base": {
          "address": 2402,
          "data_type": "BITMAP32",
          "registers": 2
        },
        "setpoint_status_validity": {
          "address": 2420,
          "data_type": "BITMAP32",
          "registers": 2
        },
        "digital_input_status_validity_slot_a": {
          "address": 2550,
          "data_type": "BITMAP32",
          "registers": 2
        },
        "digital_input_status_validity_slot_b": {
          "address": 2552,
          "data_type": "BITMAP32",
          "registers": 2
        },
        "digital_input_status_validity_slot_c": {
          "address": 2554,
          "data_type": "BITMAP32",
          "registers": 2
        },
        "digital_input_status_validity_slot_d": {
          "address": 2556,
          "data_type": "BITMAP32",
          "registers": 2
        },
        "digital_output_status_validity_slot_a": {
          "address": 2566,
          "data_type": "BITMAP32",
          "registers": 2
        },
        "digital_output_status_validity_slot_b": {
          "address": 2568,
          "data_type": "BITMAP32",
          "registers": 2
        },
        "digital_output_status_validity_slot_c": {
          "address": 2570,
          "data_type": "BITMAP32",
          "registers": 2
        },
        "digital_output_status_validity_slot_d": {
          "address": 2572,
          "data_type": "BITMAP32",
          "registers": 2
        },
        "current_disturbance": {
          "address": 13598,
          "data_type": "INT32U",
          "registers": 2
        },
        "voltage_disturbance": {
          "address": 13600,
          "data_type": "INT32U",
          "registers": 2
        }
      }
    }
  }
}
solarMeter_register_values.json
{
  "voltage_ab_v": 355.0,
  "voltage_bc_v": 401.0,
  "voltage_ca_v": 399.0,
  "voltage_ll_avg_v": 400.0,
  "voltage_an_v": 231.0,
  "voltage_bn_v": 230.5,
  "voltage_cn_v": 229.8,
  "voltage_ln_avg_v": 230.4,
  "current_a_a": 9.1,
  "current_b_a": 10.0,
  "current_c_a": 9.8,
  "current_n_a": 0.3,
  "current_avg_a": 10.0,
  "power_kw": 2.1,
  "reactive_power_total_kvar": 1.1,
  "apparent_power_total_kva": 5.3,
  "frequency_hz": 50.0,
  "pf_total": 0.98,
  "pf_a": 0.98,
  "pf_b": 0.97,
  "pf_c": 0.99,
  "active_energy_delivered_kwh": 12345.6,
  "active_energy_received_kwh": 234.5,
  "active_energy_delivered_plus_received_kwh": 12580.1,
  "active_energy_delivered_minus_received_kwh": 12111.1,
  "reactive_energy_delivered_kvarh": 5432.1,
  "reactive_energy_received_kvarh": 321.0,
  "reactive_energy_delivered_plus_received_kvarh": 5753.1,
  "reactive_energy_delivered_minus_received_kvarh": 5111.1,
  "apparent_energy_delivered_kvah": 14000.0,
  "apparent_energy_received_kvah": 250.0,
  "apparent_energy_delivered_plus_received_kvah": 14250.0,
  "apparent_energy_delivered_minus_received_kvah": 13750.0,
  "active_power_a_kw": 1.7,
  "active_power_b_kw": 1.6,
  "active_power_c_kw": 1.9,
  "reactive_power_a_kvar": 0.3,
  "reactive_power_b_kvar": 0.4,
  "reactive_power_c_kvar": 0.5,
  "apparent_power_a_kva": 1.8,
  "apparent_power_b_kva": 1.7,
  "apparent_power_c_kva": 2.0,
  "digital_input_status_validity_base": 0,
  "digital_output_status_validity_base": 0,
  "setpoint_status_validity": 0,
  "digital_input_status_validity_slot_a": 0,
  "digital_input_status_validity_slot_b": 0,
  "digital_input_status_validity_slot_c": 0,
  "digital_input_status_validity_slot_d": 0,
  "digital_output_status_validity_slot_a": 0,
  "digital_output_status_validity_slot_b": 0,
  "digital_output_status_validity_slot_c": 0,
  "digital_output_status_validity_slot_d": 0,
  "current_disturbance": 0,
  "voltage_disturbance": 0
}
solarMeter_sim_par.json
{
  "update_interval_sec": 5,
  "voltage_ll_v": { "min": 398.0, "max": 403.0, "jitter": 0.4 },
  "voltage_ln_v": { "min": 229.0, "max": 232.0, "jitter": 0.3 },
  "current_a":    { "min": 0.0,   "max": 120.0, "jitter": 1.5 },
  "frequency_hz": { "min": 49.95, "max": 50.05, "jitter": 0.02 },
  "power_kw":     { "min": 0.0,   "max": 250.0, "jitter": 3.0 },
  "kvar":         { "min": -50.0, "max": 50.0,  "jitter": 1.0 },
  "kva":          { "min": 0.0,   "max": 255.0, "jitter": 3.0 },
  "pf":           { "min": 0.95,  "max": 1.00,  "jitter": 0.01 },
  "bitmap_on_prob": 0.01
}
solarMeter_modbus_config.json
{
  "ip": "127.0.0.1",
  "port": 1501,
  "unit_id": 1,
  "poll_interval_ms": 5000,
  "save_interval_ms": 10000,
  "log_level": "INFO"
}

Note

solarMeterData/ currently holds no sample payload, so none is shown here. The emitted samples follow the same solar_* record shape as the other meters, batched by the client.