node-red-contrib-ntrip 0.2.7 → 0.2.8

package/.github/workflows/node.js.yml

@@ -19,9 +19,9 @@ jobs:
                 # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
 
         steps:
-            - uses: actions/checkout@v4
+            - uses: actions/checkout@v6
             - name: Use Node.js ${{ matrix.node-version }}
-              uses: actions/setup-node@v4
+              uses: actions/setup-node@v6
               with:
                   node-version: ${{ matrix.node-version }}
                   cache: 'npm'

package/.github/workflows/release.yml

@@ -23,9 +23,9 @@ jobs:
             matrix:
                 node-version: [18.x, 20.x, 22.x]
         steps:
-            - uses: actions/checkout@v4
+            - uses: actions/checkout@v6
             - name: Use Node.js ${{ matrix.node-version }}
-              uses: actions/setup-node@v4
+              uses: actions/setup-node@v6
               with:
                   node-version: ${{ matrix.node-version }}
                   cache: 'npm'
@@ -38,8 +38,8 @@ jobs:
         needs: test
         runs-on: ubuntu-latest
         steps:
-            - uses: actions/checkout@v4
-            - uses: actions/setup-node@v4
+            - uses: actions/checkout@v6
+            - uses: actions/setup-node@v6
               with:
                   node-version: 20
                   registry-url: 'https://registry.npmjs.org/'
@@ -54,11 +54,11 @@ jobs:
         permissions:
             contents: write
         steps:
-            - uses: actions/checkout@v4
+            - uses: actions/checkout@v6
               with:
                   fetch-depth: 0
             - name: Create GitHub Release
-              uses: softprops/action-gh-release@v2
+              uses: softprops/action-gh-release@v3
               with:
                   tag_name: ${{ github.ref_name }}
                   name: ${{ github.ref_name }}

package/CHANGELOG.md

@@ -1,6 +1,14 @@
 # Changelog
 All notable changes to this project will be documented in this file.
 
+## [0.2.8]
+### Added RTCM Encoder node
+- New `RtcmEncoder` node — inverse of `RtcmDecoder`. Accepts an `RtcmMessage` instance (or `msg.payload.message` from the decoder) and emits the encoded RTCM 3 frame as `msg.payload.rtcmMessage` (Buffer).
+- Designed for round-trip flows: decode, optionally mutate, then re-encode for forwarding.
+- Does not construct messages from plain fields (unlike the NMEA encoder) — there are 187 RTCM message types in `@gnss/rtcm` and per-type constructors are rarely needed for real flows.
+- New example flow `examples/rtcm-encode.json` demonstrating the decode → encode round-trip.
+- 6 new specs in `test/rtcm-encoder.spec.js` covering: round-trip from decoder instance, decoder-output-shape input, non-`RtcmMessage` rejected to error output, empty payload rejected, no `node.error` flood on bad input, fixture sanity.
+
 ## [0.2.7]
 ### Internal — tooling, tests, docs (no runtime changes)
 - Added a mocha test suite (14 specs across `NmeaDecoder`, `NmeaEncoder`, `RtcmDecoder`) using `node-red-node-test-helper`. Regression specs are tagged so they can be re-run with `mocha -g regression`.

package/README.md

@@ -155,6 +155,46 @@ msg.payload =
 };
 ```
 
+# RTCM Encoder Node
+Encodes an `RtcmMessage` instance back into a binary RTCM 3 frame using the
+`@gnss/rtcm` library. The inverse of the RTCM Decoder — useful for re-emitting
+a decoded frame after modification (e.g. rewriting a station ID before
+forwarding) or for synthesising test fixtures.
+
+The node has **two outputs**: encoded frames go to the first, failures to the
+second.
+
+This encoder does **not** construct an `RtcmMessage` from plain fields. The
+input must already be an instance — typically `msg.payload.message` from the
+RTCM Decoder.
+
+Input shape:
+```javascript
+// Direct: pass an RtcmMessage instance
+msg.payload = <RtcmMessage instance>;
+
+// Or pipe the decoder's success output straight through:
+msg.payload = {
+    rtcm,         // number — echoed back
+    messageType,  // string — echoed back
+    message,      // RtcmMessage instance — what gets encoded
+    input         // ignored
+};
+```
+
+Successful output:
+```javascript
+msg.payload =
+{
+    rtcmMessage,  // Buffer — the encoded RTCM 3 frame, ready to forward
+    rtcm,         // number — the RTCM message type identifier
+    messageType,  // string — the constructor name
+    input,        // the original input as supplied
+};
+```
+
+See also example flow [**RTCM encode flow**](examples/rtcm-encode.json).
+
 # NMEA Decoder Node
 This node accepts NMEA 0183 sentences as a string or `Buffer`. Multiple
 sentences in a single input (delimited by `\r\n`) are split and decoded

package/examples/rtcm-encode.json

@@ -0,0 +1 @@
+[{"id":"rtcm-encode-tab","type":"tab","label":"RTCM encode round-trip","disabled":false,"info":"Decode a known RTCM 1005 frame, then re-encode it via the RTCM Encoder node.\nWatch the two debug nodes — the encoded output should match the original bytes.\n"},{"id":"inj-1","type":"inject","z":"rtcm-encode-tab","name":"Trigger","props":[{"p":"payload"}],"repeat":"","crontab":"","once":false,"onceDelay":0.1,"topic":"","payload":"","payloadType":"date","x":140,"y":140,"wires":[["fn-load-rtcm"]]},{"id":"fn-load-rtcm","type":"function","z":"rtcm-encode-tab","name":"Load RTCM 1005 sample","func":"// A real RTCM 3 type 1005 (Stationary RTK Reference Station ARP) frame.\nmsg.payload = Buffer.from('D300133ED7D30202980EDEEF34B4BD62AC0941986F33360B98', 'hex');\nreturn msg;\n","outputs":1,"timeout":0,"noerr":0,"initialize":"","finalize":"","libs":[],"x":330,"y":140,"wires":[["decoder","dbg-raw"]]},{"id":"dbg-raw","type":"debug","z":"rtcm-encode-tab","name":"Raw RTCM bytes","active":true,"tosidebar":true,"console":false,"tostatus":false,"complete":"true","targetType":"full","statusVal":"","statusType":"auto","x":540,"y":80,"wires":[]},{"id":"decoder","type":"RtcmDecoder","z":"rtcm-encode-tab","description":"","x":540,"y":140,"wires":[["encoder","dbg-decoded"],["dbg-err"]]},{"id":"dbg-decoded","type":"debug","z":"rtcm-encode-tab","name":"Decoded frame","active":true,"tosidebar":true,"console":false,"tostatus":false,"complete":"true","targetType":"full","statusVal":"","statusType":"auto","x":740,"y":80,"wires":[]},{"id":"encoder","type":"RtcmEncoder","z":"rtcm-encode-tab","description":"","x":740,"y":140,"wires":[["dbg-encoded"],["dbg-err"]]},{"id":"dbg-encoded","type":"debug","z":"rtcm-encode-tab","name":"Re-encoded RTCM","active":true,"tosidebar":true,"console":false,"tostatus":false,"complete":"true","targetType":"full","statusVal":"","statusType":"auto","x":940,"y":140,"wires":[]},{"id":"dbg-err","type":"debug","z":"rtcm-encode-tab","name":"decode/encode error","active":true,"tosidebar":true,"console":false,"tostatus":false,"complete":"true","targetType":"full","statusVal":"","statusType":"auto","x":740,"y":220,"wires":[]}]

package/ntrip/99-ntrip.html

@@ -301,6 +301,88 @@
 
 <!-- ------------------------------------------------------------------------------------------ -->
 
+<script type="text/javascript">
+    RED.nodes.registerType('RtcmEncoder', {
+        category: 'GNSS',
+        color: '#C0DEED',
+        defaults: {
+			description: { value:"" },
+        },
+        inputs: 1,
+        outputs: 2,
+        icon: "function.png",
+        paletteLabel: "RTCM Encoder",
+        label: function () {
+            return this.description || "RTCM Encoder";
+        },
+        labelStyle: function() {
+            return this.description?"node_label_italic":"";
+        }
+    });
+
+</script>
+
+<script type="text/x-red" data-template-name="RtcmEncoder">
+    <div class="form-row">
+        <label for="node-input-description"><i class="fa fa-comment"></i> Description</label>
+        <input type="text" id="node-input-description" placeholder="The description of the node (optional)">
+    </div>
+</script>
+
+<script type="text/x-red" data-help-name="RtcmEncoder">
+    <p>Encodes an <code>RtcmMessage</code> instance back into a binary RTCM 3
+       frame using the <code>@gnss/rtcm</code> library. The inverse of the
+       <i>RTCM Decoder</i> — useful for re-emitting a decoded frame after
+       modification (e.g. rewriting a station ID before forwarding upstream).</p>
+    <p>This encoder does not construct an <code>RtcmMessage</code> from plain
+       fields. The input must already be an instance — typically the
+       <code>msg.payload.message</code> emitted by the decoder.</p>
+
+    <h3>Configuration</h3>
+    <dl class="message-properties">
+        <dt>Description <span class="property-type">string</span></dt>
+        <dd>Optional label shown in the flow editor.</dd>
+    </dl>
+
+    <h3>Inputs</h3>
+    <dl class="message-properties">
+        <dt>payload <span class="property-type">RtcmMessage</span></dt>
+        <dd>An <code>RtcmMessage</code> instance, encoded directly.</dd>
+        <dt>payload.message <span class="property-type">RtcmMessage</span></dt>
+        <dd>Round-trip shape from the <i>RTCM Decoder</i> — the encoder picks
+            up <code>msg.payload.message</code> and encodes that.</dd>
+    </dl>
+
+    <h3>Outputs</h3>
+    <p>Two outputs: successfully encoded frames go to the first; failures go to the second.</p>
+    <ol class="node-ports">
+        <li>Encoded
+            <dl class="message-properties">
+                <dt>payload.rtcmMessage <span class="property-type">Buffer</span></dt>
+                <dd>The encoded RTCM 3 frame, ready to forward to an NTRIP
+                    uploader or a TCP sink.</dd>
+                <dt>payload.rtcm <span class="property-type">number</span></dt>
+                <dd>The RTCM message type identifier (e.g. <code>1005</code>).</dd>
+                <dt>payload.messageType <span class="property-type">string</span></dt>
+                <dd>The constructor name (e.g. <code>StationArp</code>).</dd>
+                <dt>payload.input <span class="property-type">any</span></dt>
+                <dd>The original input as supplied.</dd>
+            </dl>
+        </li>
+        <li>Error
+            <dl class="message-properties">
+                <dt>payload.error <span class="property-type">Error | string</span></dt>
+                <dd>The exception thrown by the encoder, or a string describing
+                    invalid input.</dd>
+                <dt>payload.input <span class="property-type">any</span></dt>
+                <dd>The offending input.</dd>
+            </dl>
+        </li>
+    </ol>
+</script>
+
+<!-- ------------------------------------------------------------------------------------------ -->
+
 <script type="text/javascript">
     RED.nodes.registerType('NmeaDecoder', {
         category: 'GNSS',

package/ntrip/99-ntrip.js

@@ -19,6 +19,9 @@ module.exports = function (RED) {
     const RtcmDecoderNode = require('./nodes/rtcm-decoder-node.js')(RED);
     RED.nodes.registerType('RtcmDecoder', RtcmDecoderNode);
 
+    const RtcmEncoderNode = require('./nodes/rtcm-encoder-node.js')(RED);
+    RED.nodes.registerType('RtcmEncoder', RtcmEncoderNode);
+
     const NmeaDecoderNode = require('./nodes/nmea-decoder-node.js')(RED);
     RED.nodes.registerType('NmeaDecoder', NmeaDecoderNode);
 

package/ntrip/nodes/rtcm-encoder-node.js

@@ -0,0 +1,90 @@
+module.exports = function (RED) {
+    'use strict';
+
+    const { RtcmTransport, RtcmMessage } = require('@gnss/rtcm');
+
+    // Maximum RTCM 3 frame size — 3-byte header + 1023-byte payload + 3-byte CRC.
+    const MaxFrameBytes = 1029;
+
+    function RtcmEncoderNode(config) {
+        RED.nodes.createNode(this, config);
+        let node = this;
+        node.rtcmMessagesReceived = 0;
+        node.invalidMessagesReceived = 0;
+
+        function updateStatus(ok) {
+            node.status({
+                fill: ok ? 'green' : 'red',
+                shape: 'ring',
+                text: 'RTCM: ' + node.rtcmMessagesReceived + ' Invalid: ' + node.invalidMessagesReceived,
+            });
+        }
+
+        this.on('input', function (msg) {
+            let payload = msg.payload;
+
+            // Accept either an RtcmMessage instance directly as msg.payload, or the
+            // shape emitted by the RtcmDecoder (msg.payload.message). Anything else
+            // routes to the error output.
+            let message;
+            if (payload instanceof RtcmMessage) {
+                message = payload;
+            } else if (payload != null && payload.message instanceof RtcmMessage) {
+                message = payload.message;
+            } else {
+                node.send([
+                    null,
+                    {
+                        payload: {
+                            error: 'Invalid input. Expected an RtcmMessage instance as msg.payload, or msg.payload.message.',
+                            input: payload,
+                        },
+                    },
+                ]);
+                node.invalidMessagesReceived++;
+                updateStatus(false);
+                return;
+            }
+
+            try {
+                let buffer = Buffer.alloc(MaxFrameBytes);
+                let length = RtcmTransport.encode(message, buffer);
+                let encoded = buffer.slice(0, length);
+                let messageType = message.constructor.name.replace('RtcmMessage', '');
+
+                node.send([
+                    {
+                        payload: {
+                            rtcmMessage: encoded,
+                            rtcm: message.messageType,
+                            messageType: messageType,
+                            input: payload,
+                        },
+                    },
+                    null,
+                ]);
+                node.rtcmMessagesReceived++;
+                updateStatus(true);
+            } catch (ex) {
+                node.send([
+                    null,
+                    {
+                        payload: {
+                            error: ex,
+                            input: payload,
+                        },
+                    },
+                ]);
+                node.invalidMessagesReceived++;
+                updateStatus(false);
+            }
+        });
+
+        this.on('close', function (done) {
+            node.status({});
+            done();
+        });
+    }
+
+    return RtcmEncoderNode;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-red-contrib-ntrip",
-    "version": "0.2.7",
+    "version": "0.2.8",
     "description": "Node for ntrip and rtcm handling.",
     "node-red": {
         "version": ">=0.1.0",

package/test/rtcm-encoder.spec.js

@@ -0,0 +1,144 @@
+'use strict';
+
+const helper = require('node-red-node-test-helper');
+const { expect } = require('chai');
+const { RtcmTransport, RtcmMessage } = require('@gnss/rtcm');
+const ntripModule = require('../ntrip/99-ntrip.js');
+
+helper.init(require.resolve('node-red'));
+
+// A real RTCM 3 message type 1005 (Stationary RTK Reference Station ARP).
+const RTCM_1005 = Buffer.from('D300133ED7D30202980EDEEF34B4BD62AC0941986F33360B98', 'hex');
+
+function flow() {
+    return [
+        { id: 'n1', type: 'RtcmEncoder', wires: [['ok'], ['err']] },
+        { id: 'ok', type: 'helper' },
+        { id: 'err', type: 'helper' },
+    ];
+}
+
+describe('RtcmEncoder', function () {
+    before(() => helper.startServer());
+    after(() => helper.stopServer());
+    afterEach(() => helper.unload());
+
+    it('encodes an RtcmMessage instance round-tripped from the decoder', function () {
+        return new Promise((resolve, reject) => {
+            helper.load(ntripModule, flow(), () => {
+                const n1 = helper.getNode('n1');
+                const ok = helper.getNode('ok');
+                const [instance] = RtcmTransport.decode(RTCM_1005);
+                ok.on('input', (msg) => {
+                    try {
+                        expect(msg.payload.rtcm).to.equal(1005);
+                        expect(msg.payload.messageType).to.be.a('string');
+                        expect(Buffer.isBuffer(msg.payload.rtcmMessage)).to.equal(true);
+                        expect(msg.payload.rtcmMessage).to.deep.equal(RTCM_1005);
+                        resolve();
+                    } catch (e) {
+                        reject(e);
+                    }
+                });
+                n1.receive({ payload: instance });
+            });
+        });
+    });
+
+    it('accepts the decoder output shape (msg.payload.message)', function () {
+        return new Promise((resolve, reject) => {
+            helper.load(ntripModule, flow(), () => {
+                const n1 = helper.getNode('n1');
+                const ok = helper.getNode('ok');
+                const [instance, length] = RtcmTransport.decode(RTCM_1005);
+                ok.on('input', (msg) => {
+                    try {
+                        expect(msg.payload.rtcm).to.equal(1005);
+                        expect(Buffer.isBuffer(msg.payload.rtcmMessage)).to.equal(true);
+                        expect(msg.payload.rtcmMessage.length).to.equal(length);
+                        resolve();
+                    } catch (e) {
+                        reject(e);
+                    }
+                });
+                // Mimic the RtcmDecoder's success payload shape.
+                n1.receive({
+                    payload: {
+                        rtcm: instance.messageType,
+                        messageType: 'StationArp',
+                        message: instance,
+                        input: RTCM_1005,
+                    },
+                });
+            });
+        });
+    });
+
+    it('routes a non-RtcmMessage payload to the error output', function () {
+        return new Promise((resolve, reject) => {
+            helper.load(ntripModule, flow(), () => {
+                const n1 = helper.getNode('n1');
+                const ok = helper.getNode('ok');
+                const err = helper.getNode('err');
+                ok.on('input', () => reject(new Error('unexpected success output')));
+                err.on('input', (msg) => {
+                    try {
+                        expect(msg.payload.error).to.be.a('string');
+                        expect(msg.payload.error.toLowerCase()).to.include('invalid');
+                        resolve();
+                    } catch (e) {
+                        reject(e);
+                    }
+                });
+                n1.receive({ payload: { foo: 'bar' } });
+            });
+        });
+    });
+
+    it('routes empty payload to the error output', function () {
+        return new Promise((resolve, reject) => {
+            helper.load(ntripModule, flow(), () => {
+                const n1 = helper.getNode('n1');
+                const err = helper.getNode('err');
+                err.on('input', (msg) => {
+                    try {
+                        expect(msg.payload.error).to.exist;
+                        resolve();
+                    } catch (e) {
+                        reject(e);
+                    }
+                });
+                n1.receive({ payload: null });
+            });
+        });
+    });
+
+    it('does not call node.error on decode-shape failure (regression: log flood)', function () {
+        return new Promise((resolve, reject) => {
+            helper.load(ntripModule, flow(), () => {
+                const n1 = helper.getNode('n1');
+                let errorCalled = false;
+                const originalError = n1.error.bind(n1);
+                n1.error = function (...args) {
+                    errorCalled = true;
+                    return originalError(...args);
+                };
+                n1.receive({ payload: 'not-an-rtcm-message' });
+                setTimeout(() => {
+                    try {
+                        expect(errorCalled).to.equal(false);
+                        resolve();
+                    } catch (e) {
+                        reject(e);
+                    }
+                }, 50);
+            });
+        });
+    });
+
+    // Sanity check: RtcmMessage is exported and the test fixture decodes to an instance.
+    it('test fixture sanity: decoded 1005 frame is an RtcmMessage instance', function () {
+        const [instance] = RtcmTransport.decode(RTCM_1005);
+        expect(instance).to.be.instanceOf(RtcmMessage);
+    });
+});