Skip to content

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.json is written as-is — this is what replaced the manual/auto simMode flag of the older simulators;
  • every other signal is generated inside its sim_par range with jitter (frequency_hz, power_kw, voltage_ll_v, voltage_ln_v, current_a, 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 — 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
  }
]