FFR Meter Simulator
ffrMeter_simulator_v5.py is a Modbus TCP simulation server that emulates an FFR
(Fast Frequency Response) energy meter — device_id: ffrEnergyMeter1, component
ffrEnergyMeter, 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/ffrMeter_modbus_config.json |
ip, port, unit_id, log_level |
simulator_config/ffrMeter_register.json |
register map: read_batches plus categories (read_only / read_write), each signal with address, data_type and registers |
simulator_config/ffrMeter_register_values.json |
values to hold — a signal listed here is written verbatim |
simulator_config/ffrMeter_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
ffrMeter_register_values.jsonis written as-is — this is what replaced the manual/autosimModeflag of the older simulators; - every other signal is generated inside its
sim_parrange withjitter(frequency_hz,power_kw,voltage_ll_v,voltage_ln_v,current_a,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 —
for example active_energy_delivered_minus_received_kwh at 2706 (FLOAT32,
2 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/ffrMeter_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 ffrMeter_simulator_v5.py
python3 ffrMeter_simulator_v5.py --debug
python3 ffrMeter_simulator_v5.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 ffrMeter_simulator_v5.py
participant Cfg as ffrMeter_modbus_config.json
participant Map as ffrMeter_register.json
participant Val as ffrMeter_register_values.json
participant Par as ffrMeter_sim_par.json
participant HR as Holding registers
participant Cli as EMS / SCADA / test client
Op->>Sim: python3 ffrMeter_simulator_v5.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["ffrMeter_simulator_v5.py"]
A --> C["simulator_config/"]
C --> C1["ffrMeter_modbus_config.json"]
C --> C2["ffrMeter_register.json"]
C --> C3["ffrMeter_register_values.json"]
C --> C4["ffrMeter_sim_par.json"]
A --> D["logs/"]
D --> D1["ffrMeter_simulator.log"]
A --> E["ffrMeterData/"]
E --> E1["ffr_data_YYYYMMDD_HHMMSS.json (written by the client, not the simulator)"]
Python Code
ffrMeter_simulator_v5.py
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Sun Aug 10 14:04:40 2025
@author: anura
"""
"""
FFR Meter Modbus TCP Simulator (PM8000-style, strict paths, no fallbacks)
Reads ONLY these files:
- emsConfig/ffr_modbus_config.json
- simulator_config/ffrMeter_register.json
- simulator_config/ffrMeter_register_values.json
- simulator_config/ffrMeter_sim_par.json
Run:
python3 ffrMeter_simulator_v5.py
python3 ffrMeter_simulator_v5.py --debug
python3 ffrMeter_simulator_v5.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/ffrMeter_modbus_config.json"
REGISTER_FILE = "simulator_config/ffrMeter_register.json"
VALUES_FILE = "simulator_config/ffrMeter_register_values.json"
SIM_PARAM_FILE = "simulator_config/ffrMeter_sim_par.json"
# -------------------------
# Logging
# -------------------------
LOG_DIR = "logs"; os.makedirs(LOG_DIR, exist_ok=True)
LOG_FILE_PATH = os.path.join(LOG_DIR, "ffrMeter_simulator.log")
def setup_logger(level: str) -> logging.Logger:
lvl = getattr(logging, level.upper(), logging.INFO)
logger = logging.getLogger("FFRSimulator")
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("FFRSimulator")
def print_help():
print("""
FFR Modbus TCP Simulator — Help
Options:
--debug Force DEBUG logging (overrides config)
--help Show this help
Required JSON files (no fallbacks):
• Modbus : emsConfig/ffr_modbus_config.json
• Registers: simulator_config/ffr_register.json
• Values : simulator_config/ffr_register_values.json
• Params : simulator_config/ffr_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", 1505)),
"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 ffr_register.json."""
data = _read_json_strict(REGISTER_FILE)
# default endianness from read_batches (first batch; all are 'big' in your 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):
# skip nulls / undefined address entries
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/ffr_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 if the param file exists but is incomplete/missing
return {
"update_interval_sec": 1,
"voltage_ll_v": {"min": 398.0, "max": 403.0, "jitter": 0.4}, # AB/BC/CA
"voltage_ln_v": {"min": 229.0, "max": 232.0, "jitter": 0.3}, # AN/BN/CN
"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": 120.0, "jitter": 2.0},
"kvar": {"min": 0.0, "max": 30.0, "jitter": 1.0},
"kva": {"min": 0.0, "max": 125.0, "jitter": 2.0},
"pf": {"min": 0.95, "max": 1.00, "jitter": 0.01},
"bitmap_on_prob": 0.02 # ~2% chance any bit toggles on each loop if not fixed in values file
}
# -------------------------
# Packing helpers (two 16-bit words per value)
# -------------------------
def pack_float32_to_words(val: float, endianness: str) -> Tuple[int, int]:
# IEEE754 float32 -> 4 bytes
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:
# if little endian words order, reverse
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) # PM8000 maps go high; make roomy
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 max(0.0, 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:
# bitmaps default to 0 unless values file overrides or small random toggles
prob = float(params.get("bitmap_on_prob", 0.02))
bits = 0
# random: each of 32 bits has small chance to be 1
for b in range(32):
if random.random() < prob:
bits |= (1 << b)
return bits
# energies often not mapped (null in JSON) so we won't reach here for them.
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"])
# pick engineering value: static override or simulated
eng_val = static_vals.get(name, simulate_value(name, sim_params))
# pack to two words
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:
# default to float32
hi, lo = pack_float32_to_words(float(eng_val), default_endianness)
words = [hi & 0xFFFF, lo & 0xFFFF]
if regs < 2: # defensive; most PM8000 points are 2 regs
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 = "FFRSim"
identity.ProductCode = "FFR"
identity.VendorUrl = "https://example.com"
identity.ProductName = "FFR Modbus Simulator"
identity.ModelName = "PM8000-Sim"
identity.MajorMinorRevision = "5.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 FFR 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
ffrMeter_register.json
{
"device_id": "ffrEnergyMeter1",
"component_type": "ffrEnergyMeter",
"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": {
"active_power_total_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
}
}
}
}
}
ffrMeter_register_values.json
{
"active_power_total_kw": 568,
"frequency_hz": 52.89,
"pf_total": 0.98
}
ffrMeter_sim_par.json
{
"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": 80.0, "jitter": 1.0 },
"frequency_hz": { "min": 49.95, "max": 50.05, "jitter": 0.02 },
"power_kw": { "min": 0.0, "max": 120.0, "jitter": 2.0 },
"kvar": { "min": 0.0, "max": 30.0, "jitter": 1.0 },
"kva": { "min": 0.0, "max": 125.0, "jitter": 2.0 },
"pf": { "min": 0.95, "max": 1.00, "jitter": 0.01 },
"bitmap_on_prob": 0.02,
"decimals": 3,
"decimals_by_name": {
"frequency_hz": 4,
"voltage_ll_avg_v": 1
}
}
ffrMeter_modbus_config.json
{
"ip": "127.0.0.1",
"port": 1515,
"unit_id": 5,
"poll_interval_ms": 3000,
"save_interval_ms": 6000,
"log_level": "INFO",
"ems_key": "ffr_meter",
"endianness": "big"
}
Sample data emitted downstream
The client batches what it reads from this simulator into ffrMeterData/, one array of
ffr_* records per flush:
ffr_data_20251109_071312.json
[
{
"timestamp": 1762668790902,
"ffr_timestamp": 1762668790902,
"ffr_active_energy_delivered_minus_received_kwh": 0.0,
"ffr_reactive_energy_delivered_kvarh": 0.0,
"ffr_reactive_energy_received_kvarh": 0.0,
"ffr_reactive_energy_delivered_minus_received_kvarh": 0.0,
"ffr_apparent_energy_delivered_kvah": 0.0,
"ffr_apparent_energy_received_kvah": 0.0,
"ffr_apparent_energy_delivered_minus_received_kvah": 0.0,
"ffr_current_a_a": null,
"ffr_current_b_a": 34.596458435058594,
"ffr_current_c_a": 75.04438018798828,
"ffr_current_n_a": 22.3002872467041,
"ffr_current_avg_a": 78.80008697509766,
"ffr_voltage_ab_v": 399.8169860839844,
"ffr_voltage_bc_v": 398.5368347167969,
"ffr_voltage_ca_v": 398.480224609375,
"ffr_voltage_ll_avg_v": 399.6066589355469,
"ffr_voltage_an_v": 230.05979919433594,
"ffr_voltage_bn_v": 229.9850616455078,
"ffr_voltage_cn_v": 229.76661682128906,
"ffr_voltage_ln_avg_v": 231.05398559570312,
"ffr_active_power_total_kw": 568.0,
"ffr_reactive_power_total_kvar": 15.028908729553223,
"ffr_apparent_power_total_kva": 5.960392475128174,
"ffr_active_power_a_kw": 1.0353314876556396,
"ffr_active_power_b_kw": 118.2483139038086,
"ffr_active_power_c_kw": 121.32705688476562,
"ffr_reactive_power_a_kvar": 28.9461612701416,
"ffr_reactive_power_b_kvar": 105.18985748291016,
"ffr_reactive_power_c_kvar": 16.01360511779785,
"ffr_apparent_power_a_kva": 74.06160736083984,
"ffr_apparent_power_b_kva": 28.47551155090332,
"ffr_apparent_power_c_kva": 76.2348403930664,
"ffr_pf_total": 0.9800000190734863,
"ffr_pf_a": 0.959299623966217,
"ffr_pf_b": 0.9715729355812073,
"ffr_pf_c": 0.9988679885864258,
"ffr_frequency_hz": 52.88999938964844,
"ffr_digital_input_status_validity_base": 33554432,
"ffr_digital_input_status_validity_base_hex": "0x02000000",
"ffr_alarm_code": 1064876289,
"ffr_alarm_code_hex": "0x3F78B901",
"ffr_setpoint_status_validity": 4194304,
"ffr_setpoint_status_validity_hex": "0x00400000",
"ffr_digital_input_status_validity_slot_a": 0,
"ffr_digital_input_status_validity_slot_a_hex": "0x00000000",
"ffr_digital_input_status_validity_slot_b": 65536,
"ffr_digital_input_status_validity_slot_b_hex": "0x00010000",
"ffr_digital_input_status_validity_slot_c": 0,
"ffr_digital_input_status_validity_slot_c_hex": "0x00000000",
"ffr_digital_input_status_validity_slot_d": 0,
"ffr_digital_input_status_validity_slot_d_hex": "0x00000000",
"ffr_digital_output_status_validity_slot_a": 0,
"ffr_digital_output_status_validity_slot_a_hex": "0x00000000",
"ffr_digital_output_status_validity_slot_b": 0,
"ffr_digital_output_status_validity_slot_b_hex": "0x00000000",
"ffr_digital_output_status_validity_slot_c": 0,
"ffr_digital_output_status_validity_slot_c_hex": "0x00000000",
"ffr_digital_output_status_validity_slot_d": 0,
"ffr_digital_output_status_validity_slot_d_hex": "0x00000000",
"ffr_current_disturbance": 43,
"ffr_voltage_disturbance": 0
},
{
"timestamp": 1762668791928,
"ffr_timestamp": 1762668791928,
"ffr_active_energy_delivered_minus_received_kwh": 0.0,
"ffr_reactive_energy_delivered_kvarh": 0.0,
"ffr_reactive_energy_received_kvarh": 0.0,
"ffr_reactive_energy_delivered_minus_received_kvarh": 0.0,
"ffr_apparent_energy_delivered_kvah": 0.0,
"ffr_apparent_energy_received_kvah": 0.0,
"ffr_apparent_energy_delivered_minus_received_kvah": 0.0,
"ffr_current_a_a": null,
"ffr_current_b_a": 34.911251068115234,
"ffr_current_c_a": 19.631057739257812,
"ffr_current_n_a": 63.448001861572266,
"ffr_current_avg_a": 17.9014892578125,
"ffr_voltage_ab_v": 399.7410888671875,
"ffr_voltage_bc_v": 401.67987060546875,
"ffr_voltage_ca_v": 399.4026184082031,
"ffr_voltage_ll_avg_v": 398.7666320800781,
"ffr_voltage_an_v": 230.6380157470703,
"ffr_voltage_bn_v": 229.9054412841797,
"ffr_voltage_cn_v": 229.41053771972656,
"ffr_voltage_ln_avg_v": 229.2162628173828,
"ffr_active_power_total_kw": 568.0,
"ffr_reactive_power_total_kvar": 96.24447631835938,
"ffr_apparent_power_total_kva": 114.62201690673828,
"ffr_active_power_a_kw": 36.53392791748047,
"ffr_active_power_b_kw": 78.92868041992188,
"ffr_active_power_c_kw": 47.102500915527344,
"ffr_reactive_power_a_kvar": 73.7249526977539,
"ffr_reactive_power_b_kvar": 92.48102569580078,
"ffr_reactive_power_c_kvar": 70.40695190429688,
"ffr_apparent_power_a_kva": 18.489398956298828,
"ffr_apparent_power_b_kva": 76.92993927001953,
"ffr_apparent_power_c_kva": 58.61423873901367,
"ffr_pf_total": 0.9800000190734863,
"ffr_pf_a": 0.9888458847999573,
"ffr_pf_b": 0.9802318215370178,
"ffr_pf_c": 0.9687566757202148,
"ffr_frequency_hz": 52.88999938964844,
"ffr_digital_input_status_validity_base": 2147483648,
"ffr_digital_input_status_validity_base_hex": "0x80000000",
"ffr_alarm_code": 1065021561,
"ffr_alarm_code_hex": "0x3F7AF079",
"ffr_setpoint_status_validity": 16777216,
"ffr_setpoint_status_validity_hex": "0x01000000",
"ffr_digital_input_status_validity_slot_a": 0,
"ffr_digital_input_status_validity_slot_a_hex": "0x00000000",
"ffr_digital_input_status_validity_slot_b": 2147483776,
"ffr_digital_input_status_validity_slot_b_hex": "0x80000080",
"ffr_digital_input_status_validity_slot_c": 0,
"ffr_digital_input_status_validity_slot_c_hex": "0x00000000",
"ffr_digital_input_status_validity_slot_d": 0,
"ffr_digital_input_status_validity_slot_d_hex": "0x00000000",
"ffr_digital_output_status_validity_slot_a": 0,
"ffr_digital_output_status_validity_slot_a_hex": "0x00000000",
"ffr_digital_output_status_validity_slot_b": 0,
"ffr_digital_output_status_validity_slot_b_hex": "0x00000000",
"ffr_digital_output_status_validity_slot_c": 131072,
"ffr_digital_output_status_validity_slot_c_hex": "0x00020000",
"ffr_digital_output_status_validity_slot_d": 0,
"ffr_digital_output_status_validity_slot_d_hex": "0x00000000",
"ffr_current_disturbance": 57,
"ffr_voltage_disturbance": 67108864
},
{
"timestamp": 1762668792942,
"ffr_timestamp": 1762668792942,
"ffr_active_energy_delivered_minus_received_kwh": 0.0,
"ffr_reactive_energy_delivered_kvarh": 0.0,
"ffr_reactive_energy_received_kvarh": 0.0,
"ffr_reactive_energy_delivered_minus_received_kvarh": 0.0,
"ffr_apparent_energy_delivered_kvah": 0.0,
"ffr_apparent_energy_received_kvah": 0.0,
"ffr_apparent_energy_delivered_minus_received_kvah": 0.0,
"ffr_current_a_a": null,
"ffr_current_b_a": 14.324228286743164,
"ffr_current_c_a": 8.811333656311035,
"ffr_current_n_a": 29.727502822875977,
"ffr_current_avg_a": 25.644906997680664,
"ffr_voltage_ab_v": 399.2162170410156,
"ffr_voltage_bc_v": 398.5303039550781,
"ffr_voltage_ca_v": 401.0107727050781,
"ffr_voltage_ll_avg_v": 401.0687561035156,
"ffr_voltage_an_v": 231.19068908691406,
"ffr_voltage_bn_v": 229.45498657226562,
"ffr_voltage_cn_v": 231.7161865234375,
"ffr_voltage_ln_avg_v": 231.56533813476562,
"ffr_active_power_total_kw": 568.0,
"ffr_reactive_power_total_kvar": 14.236580848693848,
"ffr_apparent_power_total_kva": 35.649452209472656,
"ffr_active_power_a_kw": 87.34569549560547,
"ffr_active_power_b_kw": 92.03306579589844,
"ffr_active_power_c_kw": 112.55396270751953,
"ffr_reactive_power_a_kvar": 120.53311920166016,
"ffr_reactive_power_b_kvar": 31.32687759399414,
"ffr_reactive_power_c_kvar": 115.29547882080078,
"ffr_apparent_power_a_kva": 69.40428924560547,
"ffr_apparent_power_b_kva": 63.41177749633789,
"ffr_apparent_power_c_kva": 39.68778991699219,
"ffr_pf_total": 0.9800000190734863,
"ffr_pf_a": 0.9998469948768616,
"ffr_pf_b": 0.9825736880302429,
"ffr_pf_c": 0.960235059261322,
"ffr_frequency_hz": 52.88999938964844,
"ffr_digital_input_status_validity_base": 8388608,
"ffr_digital_input_status_validity_base_hex": "0x00800000",
"ffr_alarm_code": 1065060851,
"ffr_alarm_code_hex": "0x3F7B89F3",
"ffr_setpoint_status_validity": 134217728,
"ffr_setpoint_status_validity_hex": "0x08000000",
"ffr_digital_input_status_validity_slot_a": 4198400,
"ffr_digital_input_status_validity_slot_a_hex": "0x00401000",
"ffr_digital_input_status_validity_slot_b": 0,
"ffr_digital_input_status_validity_slot_b_hex": "0x00000000",
"ffr_digital_input_status_validity_slot_c": 536870912,
"ffr_digital_input_status_validity_slot_c_hex": "0x20000000",
"ffr_digital_input_status_validity_slot_d": 0,
"ffr_digital_input_status_validity_slot_d_hex": "0x00000000",
"ffr_digital_output_status_validity_slot_a": 0,
"ffr_digital_output_status_validity_slot_a_hex": "0x00000000",
"ffr_digital_output_status_validity_slot_b": 0,
"ffr_digital_output_status_validity_slot_b_hex": "0x00000000",
"ffr_digital_output_status_validity_slot_c": 0,
"ffr_digital_output_status_validity_slot_c_hex": "0x00000000",
"ffr_digital_output_status_validity_slot_d": 65536,
"ffr_digital_output_status_validity_slot_d_hex": "0x00010000",
"ffr_current_disturbance": 44,
"ffr_voltage_disturbance": 524288
}
]