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.jsonis written as-is — this is what replaced the manual/autosimModeflag 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_parrange withjitter(voltage_ll_v,voltage_ln_v,current_a,frequency_hz,power_kw,kvar,kva,pf); bitmap_on_probdrives the probability that a status/bitmap word has bits set;- values are encoded as declared by the register map:
FLOAT32,INT32UandBITMAP32span two registers, with endianness taken from the batch (read_batches[].endianness,bigby 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.