@atelieruldetehnologii/node-red-custome-solutions 0.62.22

package/scada-aggregator/scada-aggregator.html

@@ -0,0 +1,108 @@
+<style>
+    .scada-aggregator-editor { --sa-border:#d7dde5; --sa-surface:#f8fafc; --sa-muted:#667085; }
+    .scada-aggregator-editor .sa-section { margin:0 0 16px; padding:14px 16px; border:1px solid var(--sa-border); border-radius:10px; background:var(--sa-surface); }
+    .scada-aggregator-editor .sa-title { margin:0 0 5px; color:#243447; font-size:15px; font-weight:600; }
+    .scada-aggregator-editor .sa-note { margin:0 0 12px; color:var(--sa-muted); font-size:12px; line-height:1.45; }
+    .scada-aggregator-editor .scada-aggregator-group { display:grid; grid-template-columns:190px minmax(240px,1fr) 34px; gap:8px; align-items:center; margin:0 0 8px; }
+    .scada-aggregator-editor .scada-aggregator-group input { width:100% !important; min-width:0; box-sizing:border-box; }
+    .scada-aggregator-editor .sa-fields { display:grid; grid-template-columns:repeat(3,minmax(150px,1fr)); gap:8px; padding:10px 12px; border:1px solid var(--sa-border); border-radius:8px; background:#fff; }
+    .scada-aggregator-editor .sa-fields label { margin:0; font-weight:600; }
+    .scada-aggregator-editor .form-tips { margin:10px 0 0; padding:10px 12px; border:1px solid #eadfb3; border-radius:7px; background:#fffdf0; color:#5e5427; line-height:1.45; }
+    .scada-aggregator-editor .form-row > label { width:130px; font-weight:600; }
+    .scada-aggregator-editor .form-row > input, .scada-aggregator-editor .form-row > select { width:calc(100% - 140px); }
+</style>
+
+<script type="text/javascript">
+    (function () {
+        const DEFAULT_GROUPS = [{ id: "grid_meter", label: "Grid meter", count: 3 }, { id: "pv_inverter", label: "PV inverter", count: 13 }, { id: "bess", label: "BESS", count: 1 }];
+        function groupsFromEditor() {
+            const groups = [];
+            $("#node-scada-aggregator-groups .scada-aggregator-group").each(function (index) {
+                const row = $(this);
+                const id = String(row.find(".scada-aggregator-group-id").val() || "").trim().toLowerCase().replace(/[^a-z0-9_]+/g, "_").replace(/^_+|_+$/g, "") || ("group_" + (index + 1));
+                groups.push({ id: id, label: String(row.find(".scada-aggregator-group-label").val() || id).trim() || id, count: 1 });
+            });
+            return groups.length ? groups : DEFAULT_GROUPS;
+        }
+        function addGroup(group) {
+            const value = group || { id: "custom_group", label: "Custom group", count: 1 };
+            const row = $("<div class='scada-aggregator-group form-row'></div>");
+            row.append("<input type='text' class='scada-aggregator-group-id' placeholder='ID'>").find("input:last").val(value.id);
+            row.append("<input type='text' class='scada-aggregator-group-label' placeholder='Denumire'>").find("input:last").val(value.label);
+            row.append("<a href='#' class='button scada-remove-aggregator-group'><i class='fa fa-trash'></i></a>");
+            row.find(".scada-remove-aggregator-group").on("click", function (event) { event.preventDefault(); row.remove(); });
+            $("#node-scada-aggregator-groups").append(row);
+        }
+        RED.nodes.registerType("scada-aggregator", {
+        category: "Atelierul de Tehnologii",
+        color: "#d9ead3",
+        defaults: {
+            license: { value: "", type: "atelier-license", required: true },
+            name: { value: "" },
+            aggregatorGroups: { value: '[{"id":"grid_meter","label":"Grid meter","count":3},{"id":"pv_inverter","label":"PV inverter","count":13},{"id":"bess","label":"BESS","count":1}]' },
+            sourceIdPath: { value: "scadaSource", validate: function (value) { return !!String(value || "").trim(); } },
+            groupIdPath: { value: "scadaGroup", validate: function (value) { return !!String(value || "").trim(); } },
+            staleAfterMs: { value: 5000, validate: function (value) { return Number(value) >= 1000; } },
+            emitIntervalMs: { value: 1000, validate: function (value) { return Number(value) >= 0; } },
+            debugEnabled: { value: false },
+            gridVoltageProfile: { value: "complete" },
+        },
+        inputs: 1,
+        outputs: 1,
+        icon: "font-awesome/fa-object-group",
+        outputLabels: function (index) { return index === 0 ? "snapshot pentru scada-server" : "diagnostics"; },
+        label: function () { return this.name || "scada-aggregator"; },
+        oneditprepare: function () {
+            let groups;
+            try { groups = JSON.parse(this.aggregatorGroups); } catch (_) { groups = null; }
+            (Array.isArray(groups) && groups.length ? groups : DEFAULT_GROUPS).forEach(addGroup);
+            $("#node-scada-add-aggregator-group").on("click", function (event) { event.preventDefault(); addGroup(); });
+            $("input[name='node-input-gridVoltageProfile'][value='" + (this.gridVoltageProfile || "complete") + "']").prop("checked", true);
+        },
+        oneditsave: function () {
+            this.aggregatorGroups = JSON.stringify(groupsFromEditor());
+            this.gridVoltageProfile = $("input[name='node-input-gridVoltageProfile']:checked").val() || "complete";
+            this.outputs = $("#node-input-debugEnabled").prop("checked") ? 2 : 1;
+        }
+    });
+    })();
+</script>
+
+<script type="text/html" data-template-name="scada-aggregator">
+    <div class="form-row"><label for="node-input-license"><i class="fa fa-key"></i> License</label><input type="text" id="node-input-license"></div>
+<div class="scada-aggregator-editor">
+    <div class="sa-section">
+    <div class="sa-title"><i class="fa fa-object-group"></i> SCADA Aggregator</div>
+    <p class="sa-note">Identifică automat sursele din <code>msg.topic</code>, meter/inverter ID, IP sau din câmpurile configurate.</p>
+    <div class="form-row"><label for="node-input-name"><i class="fa fa-tag"></i> Name</label><input type="text" id="node-input-name"></div>
+    <div class="form-row"><label><i class="fa fa-object-group"></i> Grupe</label><span>ID și denumire</span></div>
+    <div id="node-scada-aggregator-groups"></div>
+    <div class="form-row"><label></label><a href="#" class="button" id="node-scada-add-aggregator-group"><i class="fa fa-plus"></i> Adaugă grupă</a></div>
+    <input type="hidden" id="node-input-sourceIdPath"><input type="hidden" id="node-input-groupIdPath">
+    <div class="form-tips">Sursele sunt recunoscute automat din <code>msg.topic</code>, meter/inverter ID, IP sau host. Pentru două aparate identice fără niciun ID în mesaj, setează doar <code>msg.topic</code> diferit înainte de agregator.</div>
+    <div class="sa-title" style="margin-top:16px;"><i class="fa fa-bolt"></i> Grid meter · date exportate</div>
+    <p class="sa-note">P, Q și frecvența sunt trimise mereu. Alege tensiunile publicate pentru fiecare grid meter.</p>
+    <div class="sa-fields">
+        <label><input type="radio" name="node-input-gridVoltageProfile" value="compact"> Compact: U L-N medie, U L-L medie</label>
+        <label><input type="radio" name="node-input-gridVoltageProfile" value="three_phase"> Trifazat: L1-N…L3-N și L1-L2…L3-L1</label>
+        <label><input type="radio" name="node-input-gridVoltageProfile" value="complete"> Complet: faze + ambele medii</label>
+    </div>
+    <div class="form-row"><label for="node-input-staleAfterMs"><i class="fa fa-clock-o"></i> Stale după (ms)</label><input type="number" id="node-input-staleAfterMs" min="1000"></div>
+    <div class="form-row"><label for="node-input-emitIntervalMs"><i class="fa fa-refresh"></i> Snapshot (ms)</label><input type="number" id="node-input-emitIntervalMs" min="0"></div>
+    <div class="form-row"><label for="node-input-debugEnabled"><i class="fa fa-bug"></i> Debug output</label><input type="checkbox" id="node-input-debugEnabled" style="width:auto;"></div>
+    </div>
+</div>
+</script>
+
+<script type="text/html" data-help-name="scada-aggregator">
+    <p>Agregă P, Q, tensiunile trifazate și frecvența de la mai multe surse într-un singur snapshot pentru <b>scada-server</b>.</p>
+    <h3>Conectare</h3>
+    <p>Etichetează fiecare mesaj cu <code>msg.scadaGroup</code> și <code>msg.scadaSource</code>, apoi conectează ieșirea 1 la <b>scada-server</b> configurat cu <b>Mod hartă: Auto-discovery</b>. Grupele implicite sunt <code>grid_meter</code>, <code>pv_inverter</code> și <code>bess</code>, dar orice grupă sau sursă nouă este acceptată automat. Un ID de sursă este unic în întregul agregator: nu poate fi reutilizat într-o altă grupă.</p>
+    <h3>Date acceptate</h3>
+    <p>Nodul acceptă forme normalizate: <code>p</code> (W), <code>q</code> (VAr), <code>f</code> (Hz), <code>u_l1n</code>, <code>u_l2n</code>, <code>u_l3n</code>, <code>u_ln_avg</code>, <code>u_l12</code>, <code>u_l23</code>, <code>u_l31</code> și <code>u_ll_avg</code> (V). Sunt acceptate și denumirile echivalente, de exemplu <code>active_power_w</code>, <code>reactive_power_var</code>, <code>frequency_hz</code> și <code>voltage_l1_l2_v</code>, inclusiv structurile produse de Fronius, Janitza și Carlo Gavazzi.</p>
+    <p>Valorile zero de tensiune și frecvență rămân vizibile la sursa individuală, dar sunt excluse automat din mediile pe faze și din mediile generale. Astfel, un invertor sau meter aflat în eroare, care raportează 0 V / 0 Hz, nu alterează valorile medii ale instalației. Puterile P și Q continuă să fie însumate.</p>
+    <h3>Totaluri</h3>
+    <ul><li>P și Q sunt însumate în fiecare grup.</li><li>Fiecare tensiune și frecvența sunt mediate numai pentru sursele online.</li><li><code>payload.scada.totals.site.grid</code> este totalul grupului <code>grid_meter</code>, iar <code>payload.scada.totals.site.pv</code> este totalul grupului <code>pv_inverter</code>.</li></ul>
+    <h3>Ieșiri</h3>
+    <p>Ieșirea 1 publică snapshot-ul <code>msg.topic = "scada-aggregator/snapshot"</code> și <code>msg.payload.scada</code>. Ieșirea 2 există numai după activarea <b>Debug output</b> și deploy; ea publică diagnosticul surselor și al totalurilor.</p>
+</script>

package/scada-aggregator/scada-aggregator.js

@@ -0,0 +1,117 @@
+module.exports = function (RED) {
+    "use strict";
+
+const { runLicensedNode } = require("../lib/licensing/node-guard");
+
+    const { normalizeMessage, summarize } = require("./lib/aggregate");
+    const { groupList } = require("./lib/groups");
+
+    function getByPath(object, path) {
+        return String(path || "scadaSource").split(".").reduce(function (value, key) {
+            return value == null ? undefined : value[key];
+        }, object);
+    }
+
+    function ScadaAggregatorNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        runLicensedNode(node, RED, config, function startLicensedRuntime() {
+        node.sourceIdPath = String(config.sourceIdPath || "scadaSource").trim() || "scadaSource";
+        node.staleAfterMs = Math.max(1000, Number(config.staleAfterMs) || 5000);
+        node.debugEnabled = !!config.debugEnabled;
+        node.gridVoltageProfile = ["compact", "three_phase", "complete"].includes(config.gridVoltageProfile) ? config.gridVoltageProfile : "complete";
+        const configuredGroups = groupList(config);
+        const groups = new Map(configuredGroups.map(function (group) { return [group.id, { id: group.id, label: group.label }]; }));
+        node.groupIdPath = String(config.groupIdPath || "scadaGroup").trim() || "scadaGroup";
+        node.siteTotalSource = String(config.siteTotalSource || configuredGroups[0].id).trim() || configuredGroups[0].id;
+        const sources = new Map();
+        const sourceGroups = new Map();
+        const state = new Map();
+        let timer = null;
+
+        function buildPayload() {
+            const now = Date.now();
+            const payload = { totals: {} };
+            const active = {};
+            groups.forEach(function (group) { payload[group.id] = {}; active[group.id] = []; });
+            sources.forEach(function (source) {
+                const entry = state.get(source.key);
+                const age = entry ? Math.max(0, Math.round((now - entry.updatedAt) / 1000)) : Math.ceil(node.staleAfterMs / 1000);
+                const online = !!entry && (now - entry.updatedAt) <= node.staleAfterMs;
+                const raw = entry ? entry.values : {};
+                const target = Object.assign({}, raw, { online: online ? 1 : 0, age_s: age });
+                if (source.group === "grid_meter") {
+                    const allowed = node.gridVoltageProfile === "compact" ? ["u_ln_avg", "u_ll_avg"] : (node.gridVoltageProfile === "three_phase" ? ["u_l1n", "u_l2n", "u_l3n", "u_l12", "u_l23", "u_l31"] : ["u_l1n", "u_l2n", "u_l3n", "u_ln_avg", "u_l12", "u_l23", "u_l31", "u_ll_avg"]);
+                    ["u_l1n", "u_l2n", "u_l3n", "u_ln_avg", "u_l12", "u_l23", "u_l31", "u_ll_avg"].forEach(function (key) { if (!allowed.includes(key)) delete target[key]; });
+                }
+                payload[source.group][source.id] = target;
+                if (online) active[source.group].push({ values: entry.values });
+            });
+            groups.forEach(function (group) { payload.totals[group.id] = summarize(active[group.id]); });
+            if (payload.totals.grid_meter) {
+                const allowed = node.gridVoltageProfile === "compact" ? ["u_ln_avg", "u_ll_avg"] : (node.gridVoltageProfile === "three_phase" ? ["u_l1n", "u_l2n", "u_l3n", "u_l12", "u_l23", "u_l31"] : ["u_l1n", "u_l2n", "u_l3n", "u_ln_avg", "u_l12", "u_l23", "u_l31", "u_ll_avg"]);
+                ["u_l1n", "u_l2n", "u_l3n", "u_ln_avg", "u_l12", "u_l23", "u_l31", "u_ll_avg"].forEach(function (key) { if (!allowed.includes(key)) delete payload.totals.grid_meter[key]; });
+            }
+            payload.totals.site = {
+                grid: Object.assign({ active: 0 }, payload.totals.grid_meter || {}),
+                pv: Object.assign({ active: 0 }, payload.totals.pv_inverter || {})
+            };
+            return payload;
+        }
+
+        function emit(reason, send) {
+            const payload = buildPayload();
+            const online = Object.values(payload.totals).reduce(function (sum, total) { return Math.max(sum, total.active || 0); }, 0);
+            node.status({ fill: online ? "green" : "yellow", shape: "dot", text: online + " active | " + reason });
+            const snapshot = { topic: "scada-aggregator/snapshot", payload: { scada: payload } };
+            const diagnostics = node.debugEnabled ? { topic: "scada-aggregator/diagnostics", payload: { reason: reason, sources: sources.size, stale_after_ms: node.staleAfterMs, totals: payload.totals } } : null;
+            send(node.debugEnabled ? [snapshot, diagnostics] : [snapshot]);
+        }
+
+        node.on("input", function (msg, send, done) {
+            try {
+                const sourceId = String(getByPath(msg, node.sourceIdPath) || msg.topic || msg.meter_id || msg.inverter_id || msg.device_id || msg.ip || msg.host || "").trim();
+                const groupId = String(getByPath(msg, node.groupIdPath) || configuredGroups[0].id).trim().toLowerCase().replace(/[^a-z0-9_]+/g, "_") || configuredGroups[0].id;
+                if (!sourceId) {
+                    node.status({ fill: "yellow", shape: "ring", text: "lipseste ID sursa" });
+                    node.warn("scada-aggregator: sursa nu poate fi identificata. Seteaza msg.topic sau msg.scadaSource.");
+                    done();
+                    return;
+                }
+                const existingGroup = sourceGroups.get(sourceId);
+                if (existingGroup && existingGroup !== groupId) {
+                    node.status({ fill: "red", shape: "ring", text: "ID duplicat: " + sourceId });
+                    node.warn("scada-aggregator: ID-ul sursei '" + sourceId + "' este deja folosit de grupa '" + existingGroup + "' si nu poate fi reutilizat in grupa '" + groupId + "'.");
+                    done();
+                    return;
+                }
+                if (!groups.has(groupId)) groups.set(groupId, { id: groupId, label: groupId });
+                const sourceKey = groupId + "." + sourceId;
+                const source = sources.get(sourceKey) || { group: groupId, id: sourceId, key: sourceKey };
+                const values = normalizeMessage(msg);
+                if (!Object.values(values).some(function (value) { return value !== null; })) {
+                    node.warn("scada-aggregator: nu exista P/Q/U/f numeric pentru " + sourceId);
+                    done();
+                    return;
+                }
+                sources.set(sourceKey, source);
+                sourceGroups.set(sourceId, groupId);
+                const previous = state.get(sourceKey);
+                const merged = Object.assign({}, previous ? previous.values : {});
+                Object.keys(values).forEach(function (key) { if (values[key] !== null) merged[key] = values[key]; });
+                state.set(sourceKey, { values: merged, updatedAt: Date.now() });
+                emit("input " + sourceId, send);
+                done();
+            } catch (error) { done(error); }
+        });
+
+        const emitIntervalMs = Math.max(0, Number(config.emitIntervalMs) || 1000);
+        if (emitIntervalMs) timer = setInterval(function () { emit("interval", node.send.bind(node)); }, emitIntervalMs);
+        node.on("close", function (done) { if (timer) clearInterval(timer); done(); });
+    
+        });
+    }
+
+    RED.nodes.registerType("scada-aggregator", ScadaAggregatorNode);
+};

package/scada-server/lib/aggregator-map.js

@@ -0,0 +1,58 @@
+"use strict";
+
+const VOLTAGE_PROFILES = {
+    compact: ["u_ln_avg", "u_ll_avg"],
+    three_phase: ["u_l1n", "u_l2n", "u_l3n", "u_l12", "u_l23", "u_l31"],
+    complete: ["u_l1n", "u_l2n", "u_l3n", "u_ln_avg", "u_l12", "u_l23", "u_l31", "u_ll_avg"]
+};
+const SIGNALS = { p: { label: "P", unit: "W" }, q: { label: "Q", unit: "VAr" }, f: { label: "F", unit: "Hz" }, u_l1n: { label: "U L1-N", unit: "V" }, u_l2n: { label: "U L2-N", unit: "V" }, u_l3n: { label: "U L3-N", unit: "V" }, u_ln_avg: { label: "U L-N medie", unit: "V" }, u_l12: { label: "U L1-L2", unit: "V" }, u_l23: { label: "U L2-L3", unit: "V" }, u_l31: { label: "U L3-L1", unit: "V" }, u_ll_avg: { label: "U L-L medie", unit: "V" } };
+const DEFAULT_GROUPS = [{ id: "grid_meter", label: "Grid meter", count: 3 }, { id: "pv_inverter", label: "PV inverter", count: 13 }, { id: "bess", label: "BESS", count: 1 }];
+
+function slug(value, fallback) { return String(value || "").toLowerCase().replace(/[^a-z0-9_]+/g, "_").replace(/^_+|_+$/g, "") || fallback; }
+function count(value, fallback) { const number = Number(value); return Number.isFinite(number) ? Math.max(0, Math.min(99, Math.round(number))) : fallback; }
+function normalizeProfile(value) { return VOLTAGE_PROFILES[value] ? value : "complete"; }
+function normalizePrefix(value) { return String(value || "payload.scada").trim().replace(/\.+$/, "") || "payload.scada"; }
+
+function groupList(config) {
+    let parsed;
+    try { parsed = typeof config.aggregatorGroups === "string" ? JSON.parse(config.aggregatorGroups) : config.aggregatorGroups; } catch (_) { parsed = null; }
+    if (!Array.isArray(parsed) || !parsed.length) return DEFAULT_GROUPS.map(function (group) { return Object.assign({}, group); });
+    const used = new Set();
+    return parsed.map(function (group, index) {
+        let id = slug(group && group.id, "group_" + (index + 1));
+        while (used.has(id)) id += "_" + (index + 1);
+        used.add(id);
+        return { id: id, label: String(group && group.label || id).trim() || id, count: count(group && group.count, 1) };
+    });
+}
+
+function sourceList(config) {
+    const list = [];
+    groupList(config).forEach(function (group) {
+        for (let index = 1; index <= group.count; index += 1) {
+            const id = group.count === 1 ? group.id : group.id + "_" + String(index).padStart(2, "0");
+            list.push({ group: group.id, id: id, label: group.count === 1 ? group.label : group.label + " " + String(index).padStart(2, "0") });
+        }
+    });
+    return list;
+}
+function metric(key, label, address, path, unit, type) { return { key: key, label: label, address: address, type: type || "float32", scale: 1, path: path, unit: unit || "", signMode: "as_is", byteOrder: "big_endian", wordOrder: "msw_first" }; }
+
+function buildAggregatorMetrics(config) {
+    const prefix = normalizePrefix(config.aggregatorPrefix);
+    const signals = ["p", "q"].concat(VOLTAGE_PROFILES[normalizeProfile(config.aggregatorVoltageProfile)], ["f"]);
+    const metrics = [];
+    const addBlock = function (group, id, label, address, total) {
+        signals.forEach(function (signal, index) { const info = SIGNALS[signal]; metrics.push(metric((total ? "total_" + group : id) + "_" + signal, (total ? "Total " + label : label) + " " + info.label, address + (index * 2), prefix + "." + (total ? "totals." + group : group + "." + id) + "." + signal, info.unit)); });
+        metrics.push(metric((total ? "total_" + group : id) + "_" + (total ? "active" : "online"), (total ? "Total " + label : label) + " " + (total ? "active" : "online"), address + 28, prefix + "." + (total ? "totals." + group : group + "." + id) + "." + (total ? "active" : "online"), "", "uint16"));
+        if (!total) metrics.push(metric(id + "_age_s", label + " age", address + 29, prefix + "." + group + "." + id + ".age_s", "s", "uint16"));
+    };
+    const sources = sourceList(config);
+    sources.forEach(function (source, index) { addBlock(source.group, source.id, source.label, index * 32, false); });
+    const totalAddress = sources.length * 32;
+    groupList(config).forEach(function (group, index) { addBlock(group.id, "", group.label, totalAddress + (index * 32), true); });
+    addBlock("site", "", "Site", totalAddress + (groupList(config).length * 32), true);
+    return metrics;
+}
+
+module.exports = { DEFAULT_GROUPS, SIGNALS, VOLTAGE_PROFILES, buildAggregatorMetrics, groupList, normalizeProfile, normalizePrefix, sourceList };

package/scada-server/lib/encoding.js

@@ -0,0 +1,235 @@
+"use strict";
+
+
+function clamp(value, min, max) {
+
+    return Math.min(Math.max(value, min), max);
+
+}
+
+
+function normalizeByteOrder(value) {
+
+    return value === "little_endian" ? "little_endian" : "big_endian";
+
+}
+
+
+function normalizeWordOrder(value) {
+
+    return value === "lsw_first" ? "lsw_first" : "msw_first";
+
+}
+
+
+function normalizeMetricValue(value) {
+
+    const numeric = Number(value);
+
+    return Number.isFinite(numeric) ? numeric : null;
+
+}
+
+
+function wordsFromInt32(value) {
+
+    const buffer = Buffer.allocUnsafe(4);
+
+    buffer.writeInt32BE(value, 0);
+
+    return [buffer.readUInt16BE(0), buffer.readUInt16BE(2)];
+
+}
+
+
+function wordsFromUInt32(value) {
+
+    const buffer = Buffer.allocUnsafe(4);
+
+    buffer.writeUInt32BE(value, 0);
+
+    return [buffer.readUInt16BE(0), buffer.readUInt16BE(2)];
+
+}
+
+
+function wordsFromFloat32(value) {
+
+    const buffer = Buffer.allocUnsafe(4);
+
+    buffer.writeFloatBE(Number(value) || 0, 0);
+
+    return [buffer.readUInt16BE(0), buffer.readUInt16BE(2)];
+
+}
+
+
+function wordsFromInt16(value) {
+
+    const buffer = Buffer.allocUnsafe(2);
+
+    buffer.writeInt16BE(value, 0);
+
+    return [buffer.readUInt16BE(0)];
+
+}
+
+
+function wordsFromUInt16(value) {
+
+    const buffer = Buffer.allocUnsafe(2);
+
+    buffer.writeUInt16BE(value, 0);
+
+    return [buffer.readUInt16BE(0)];
+
+}
+
+
+function integerRangeForType(type) {
+
+    switch (type) {
+        case "int16":
+            return { min: -32768, max: 32767 };
+        case "uint16":
+            return { min: 0, max: 65535 };
+        case "uint32":
+            return { min: 0, max: 0xFFFFFFFF };
+        case "int32":
+            return { min: -2147483648, max: 2147483647 };
+        default:
+            return null;
+    }
+
+}
+
+
+function applyWordOrder(words, wordOrder) {
+
+    if (words.length === 2 && normalizeWordOrder(wordOrder) === "lsw_first") {
+        return [words[1], words[0]];
+    }
+
+    return words.slice();
+
+}
+
+
+function applyByteOrder(words, byteOrder) {
+
+    if (normalizeByteOrder(byteOrder) !== "little_endian") {
+        return words.slice();
+    }
+
+    return words.map(function (word) {
+        return ((word & 0x00FF) << 8) | ((word & 0xFF00) >> 8);
+    });
+
+}
+
+
+function applyRegisterOrder(words, options) {
+
+    return applyByteOrder(applyWordOrder(words, options && options.wordOrder), options && options.byteOrder);
+
+}
+
+
+function encodeMetricDetailed(value, type, scale, options) {
+
+    const normalized = normalizeMetricValue(value);
+
+    if (!Number.isFinite(normalized)) {
+
+        return {
+            words: [],
+            issues: []
+        };
+
+    }
+
+
+    const scaled = normalized * Number(scale || 1);
+    const issues = [];
+    let words;
+
+    switch (type) {
+
+        case "float32":
+
+            words = wordsFromFloat32(scaled);
+            break;
+
+        case "int16":
+
+            words = wordsFromInt16(clamp(Math.round(scaled), -32768, 32767));
+            break;
+
+        case "uint16":
+
+            words = wordsFromUInt16(clamp(Math.round(scaled), 0, 65535));
+            break;
+
+        case "uint32":
+
+            words = wordsFromUInt32(clamp(Math.round(scaled), 0, 0xFFFFFFFF));
+            break;
+
+        case "int32":
+
+        default:
+
+            words = wordsFromInt32(clamp(Math.round(scaled), -2147483648, 2147483647));
+            break;
+
+    }
+
+    const range = integerRangeForType(type);
+    if (range && (Math.round(scaled) < range.min || Math.round(scaled) > range.max)) {
+        issues.push({
+            code: "value_saturated",
+            type: type,
+            raw_value: normalized,
+            scaled_value: scaled,
+            min: range.min,
+            max: range.max
+        });
+    }
+
+    return {
+        words: applyRegisterOrder(words, options || {}),
+        issues: issues
+    };
+
+}
+
+
+function encodeMetric(value, type, scale, options) {
+
+    return encodeMetricDetailed(value, type, scale, options).words;
+
+}
+
+
+function typeWordLength(type) {
+
+    return (type === "int16" || type === "uint16") ? 1 : 2;
+
+}
+
+
+module.exports = {
+
+    encodeMetric,
+
+    encodeMetricDetailed,
+
+    normalizeMetricValue,
+
+    normalizeByteOrder,
+
+    normalizeWordOrder,
+
+    typeWordLength
+
+};