node-red-contrib-ntrip 0.2.3 → 0.2.8

package/ntrip/99-ntrip.html

@@ -13,8 +13,8 @@
             passthrough: { value: false, required: false },
            
             port: { value: 2101, required: false, validate:function(v) { return ((v === "") || (RED.validators.number(v) && (v >= 0) && (v <= 65535))) }},
-            host: { value:"" },
-            mountpoint: { value:"" },
+            host: { value:"", required: true, validate: function(v) { return typeof v === "string" && v.trim().length > 0; } },
+            mountpoint: { value:"", required: true, validate: function(v) { return typeof v === "string" && v.trim().length > 0; } },
             interval: { value: 1000, required: false, validate:function(v) { return ((v === "") || (RED.validators.number(v) && (v >= 0) && (v <= 100000))) }},
             xcoordinate: { value: 0, required: false, validate:function(v) { return ((v === "") || (RED.validators.number(v) )) }},
             ycoordinate: { value: 0, required: false, validate:function(v) { return ((v === "") || (RED.validators.number(v) )) }},
@@ -108,7 +108,7 @@
     </div>
     <div class="form-row">
         <label for="node-input-password"><i class="fa fa-key"></i> Password</label>
-        <input type="text" id="node-input-password" placeholder="Enter the password here)">
+        <input type="password" id="node-input-password" placeholder="Enter the password here">
     </div>
     
     <hr align="middle"/>
@@ -140,18 +140,83 @@
 </script>
 
 <script type="text/x-red" data-help-name="NtripClient">
-    <p>A node that connects to a NTRIP server.</p>
+    <p>Connects to an NTRIP caster as either a client (download) or a server (upload).
+       In download mode the node emits the bytes received from the caster (typically
+       RTCM correction data). In upload mode the node forwards bytes from its input
+       to the caster on the configured mountpoint.</p>
 
     <h3>Configuration</h3>
+    <dl class="message-properties">
+        <dt>Host <span class="property-type">string</span></dt>
+        <dd>Hostname or IP address of the NTRIP caster (e.g. <code>rtk2go.com</code>).</dd>
+
+        <dt>Port <span class="property-type">number</span></dt>
+        <dd>TCP port of the caster. Defaults to <code>2101</code>.</dd>
+
+        <dt>Mountpoint <span class="property-type">string</span></dt>
+        <dd>The stream name on the caster. Enter the name without a leading slash.</dd>
+
+        <dt>Mode <span class="property-type">"download" | "upload"</span></dt>
+        <dd><b>Download</b>: receive correction data from the caster.<br>
+            <b>Upload</b>: push correction data to a mountpoint on the caster.</dd>
+
+        <dt>Authentication Mode <span class="property-type">string</span></dt>
+        <dd>Upload only. Selects the handshake the caster expects:
+            <ul>
+                <li><b>Legacy (Plain Text)</b> — <code>SOURCE</code> with no auth header, accepted by rtk2go.</li>
+                <li><b>Legacy (Basic Auth)</b> — <code>SOURCE</code> plus an <code>Authorization: Basic</code> header, accepted by SNIP.</li>
+                <li><b>NTRIP V1</b> — <code>POST</code> over HTTP/1.0 with Basic Auth.</li>
+                <li><b>NTRIP V2</b> — <code>POST</code> over HTTP/1.1 with Basic Auth and <code>Ntrip-Version: Ntrip/2.0</code>.</li>
+            </ul>
+        </dd>
+
+        <dt>Pass through data <span class="property-type">boolean</span></dt>
+        <dd>Upload only. If enabled, bytes written to the caster are also re-emitted
+            on the node's output for downstream processing.</dd>
+
+        <dt>Username / Password <span class="property-type">credential</span></dt>
+        <dd>Caster credentials. Stored encrypted by Node-RED.</dd>
+
+        <dt>X / Y / Z <span class="property-type">number</span></dt>
+        <dd>Optional ECEF coordinate triple. If set (i.e. not all zero) the underlying
+            client generates and periodically sends a NMEA <code>GGA</code> sentence to
+            the caster — required by some VRS / network-RTK services.</dd>
+
+        <dt>Interval <span class="property-type">number (ms)</span></dt>
+        <dd>Period between <code>GGA</code> emissions when X/Y/Z are configured.</dd>
+    </dl>
 
-    <p>Description of the device.</p>
-    
     <h3>Inputs</h3>
-    <p>Content is directly passed to the ntrip server.</p>
-    
+    <dl class="message-properties">
+        <dt>payload <span class="property-type">Buffer | string</span></dt>
+        <dd>Written verbatim to the caster (upload mode). In download mode the input
+            is typically only used to refresh the position via the form below.</dd>
+
+        <dt>payload <span class="property-type">number[]</span></dt>
+        <dd>An array <code>[x, y, z]</code> is interpreted as a coordinate update and
+            forwarded to <code>client.setXYZ()</code> rather than being written to the
+            caster. Useful for streaming position fixes into the GGA emitter.</dd>
+    </dl>
+
     <h3>Outputs</h3>
-    <p>Messages received from the ntrip server.</p>
-    <p><code>msg.payload</code></p>
+    <dl class="message-properties">
+        <dt>payload <span class="property-type">Buffer</span></dt>
+        <dd>Bytes received from the caster. In download mode this is the correction
+            stream (RTCM). In upload mode with <i>Pass through data</i> enabled, written
+            bytes are also re-emitted here.</dd>
+    </dl>
+
+    <h3>Status</h3>
+    <p>The node shows <code>connecting…</code> until the caster acknowledges the
+       handshake with <code>ICY 200 OK</code>. After that it shows the running
+       <code>Rx</code> / <code>Tx</code> counters. A red badge indicates a rejected
+       connection, a missing mountpoint, or a write failure.</p>
+
+    <h3>Details</h3>
+    <p>The first <code>ICY 200 OK</code>, <code>ICY 406</code>, or
+       <code>SOURCETABLE 200 OK</code> reply is consumed by the node to set its
+       status; any RTCM bytes that arrive in the same TCP segment as the
+       <code>ICY 200 OK</code> reply are forwarded on the output.</p>
 </script>
 
 
@@ -186,18 +251,134 @@
 </script>
 
 <script type="text/x-red" data-help-name="RtcmDecoder">
-    <p>A node that decodes RTCM messages.</p>
+    <p>Decodes binary RTCM (Radio Technical Commission for Maritime Services)
+       correction frames using the <code>@gnss/rtcm</code> library. One input
+       message may contain a single frame or several concatenated frames; each
+       decoded frame is emitted as its own output message.</p>
+    <p>The node keeps an internal buffer so frames that straddle TCP packet
+       boundaries are reassembled across consecutive input events.</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>
 
-    <p>Description of the device.</p>
-    
     <h3>Inputs</h3>
-    <p>.</p>
-    
+    <dl class="message-properties">
+        <dt>payload <span class="property-type">Buffer</span></dt>
+        <dd>Raw RTCM bytes, typically produced by the upstream <i>NTRIP Client</i>
+            node. Strings are accepted but converted via <code>Buffer.from</code>.</dd>
+    </dl>
+
     <h3>Outputs</h3>
-    <p>.</p>
-    <p><code>msg.payload</code></p>
+    <p>Two outputs: successfully decoded frames go to the first; decode failures go to the second.</p>
+    <ol class="node-ports">
+        <li>Decoded
+            <dl class="message-properties">
+                <dt>payload.rtcm <span class="property-type">number</span></dt>
+                <dd>The RTCM message type identifier (e.g. <code>1005</code>, <code>1077</code>).</dd>
+                <dt>payload.messageType <span class="property-type">string</span></dt>
+                <dd>The constructor name of the decoded message (e.g. <code>1005</code> → <code>Stationary</code>).</dd>
+                <dt>payload.message <span class="property-type">object</span></dt>
+                <dd>The decoded message object with all fields.</dd>
+                <dt>payload.input <span class="property-type">Buffer</span></dt>
+                <dd>The bytes consumed for this frame.</dd>
+            </dl>
+        </li>
+        <li>Error
+            <dl class="message-properties">
+                <dt>payload.error <span class="property-type">Error</span></dt>
+                <dd>The exception thrown by the decoder.</dd>
+                <dt>payload.input <span class="property-type">Buffer</span></dt>
+                <dd>The remaining buffer at the point of failure.</dd>
+                <dt>payload.inputString <span class="property-type">string</span></dt>
+                <dd>A debug string representation of the buffer.</dd>
+            </dl>
+        </li>
+    </ol>
+</script>
+
+<!-- ------------------------------------------------------------------------------------------ -->
+
+<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>
 
 <!-- ------------------------------------------------------------------------------------------ -->
@@ -231,18 +412,52 @@
 </script>
 
 <script type="text/x-red" data-help-name="NmeaDecoder">
-    <p>A node that decodes NMEA messages.</p>
+    <p>Decodes NMEA 0183 sentences (<code>GGA</code>, <code>RMC</code>,
+       <code>GSV</code>, …) using the <code>@gnss/nmea</code> library. A single
+       input message may contain several <code>\r\n</code>-delimited sentences;
+       each is decoded individually and emitted as its own output message.</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>
 
-    <p>Description of the device.</p>
-    
     <h3>Inputs</h3>
-    <p>.</p>
-    
+    <dl class="message-properties">
+        <dt>payload <span class="property-type">string | Buffer</span></dt>
+        <dd>A NMEA sentence or a chunk containing several sentences. Buffers are
+            decoded as UTF-8.</dd>
+        <dt>payload.nmeaMessage <span class="property-type">string | Buffer</span></dt>
+        <dd>Alternative location for the input. If <code>msg.payload</code> is an
+            object with an <code>nmeaMessage</code> property, that value is used
+            instead of <code>msg.payload</code> itself.</dd>
+    </dl>
+
     <h3>Outputs</h3>
-    <p>.</p>
-    <p><code>msg.payload</code></p>
+    <p>Two outputs: successfully decoded sentences go to the first; decode failures go to the second.</p>
+    <ol class="node-ports">
+        <li>Decoded
+            <dl class="message-properties">
+                <dt>payload.messageType <span class="property-type">string</span></dt>
+                <dd>Sentence type in upper case, e.g. <code>GGA</code>, <code>RMC</code>, <code>GSV</code>.</dd>
+                <dt>payload.nmeaMessage <span class="property-type">object</span></dt>
+                <dd>The decoded sentence object with all fields.</dd>
+                <dt>payload.input <span class="property-type">string</span></dt>
+                <dd>The raw sentence as it was parsed.</dd>
+            </dl>
+        </li>
+        <li>Error
+            <dl class="message-properties">
+                <dt>payload.error <span class="property-type">Error | string</span></dt>
+                <dd>The exception or reason for the decode failure.</dd>
+                <dt>payload.input <span class="property-type">string</span></dt>
+                <dd>The sentence that failed to decode.</dd>
+                <dt>payload.inputString <span class="property-type">string</span></dt>
+                <dd>String representation of the input for logging.</dd>
+            </dl>
+        </li>
+    </ol>
 </script>
 
 <!-- ------------------------------------------------------------------------------------------ -->
@@ -276,16 +491,59 @@
 </script>
 
 <script type="text/x-red" data-help-name="NmeaEncoder">
-    <p>A node that encodes NMEA messages.</p>
+    <p>Encodes a NMEA sentence object back to its textual form using the
+       <code>@gnss/nmea</code> library. The inverse of the <i>NMEA Decoder</i>
+       node — useful for round-tripping or for emitting handcrafted sentences
+       (e.g. a <code>GGA</code> fix into an NTRIP uploader).</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>
 
-    <p>Description of the device.</p>
-    
     <h3>Inputs</h3>
-    <p>.</p>
-    
+    <dl class="message-properties">
+        <dt>payload.messageType <span class="property-type">string</span></dt>
+        <dd>Sentence type, e.g. <code>GGA</code>, <code>RMC</code>, <code>VTG</code>,
+            <code>GSV</code>, <code>ZDA</code>. Case-insensitive. Supported types:
+            <code>DTM</code>, <code>GBS</code>, <code>GGA</code>, <code>GLL</code>,
+            <code>GNS</code>, <code>GRS</code>, <code>GSA</code>, <code>GST</code>,
+            <code>GSV</code>, <code>RMC</code>, <code>THS</code>, <code>TXT</code>,
+            <code>VHW</code>, <code>VLW</code>, <code>VPW</code>, <code>VTG</code>,
+            <code>ZDA</code>, plus <code>OBJECT</code> for the generic
+            <code>NmeaMessageUnknown</code> form.</dd>
+        <dt>payload.nmeaMessage <span class="property-type">object | NmeaMessage</span></dt>
+        <dd>The sentence content. Either a plain field object that matches the
+            target sentence schema, or an already-constructed <code>NmeaMessage</code>
+            instance (which is forwarded as-is to <code>NmeaTransport.encode</code>).</dd>
+    </dl>
+
     <h3>Outputs</h3>
-    <p>.</p>
-    <p><code>msg.payload</code></p>
+    <p>Two outputs: successfully encoded sentences go to the first; failures go to the second.</p>
+    <ol class="node-ports">
+        <li>Encoded
+            <dl class="message-properties">
+                <dt>payload.nmeaMessage <span class="property-type">string</span></dt>
+                <dd>The encoded NMEA sentence (including <code>$</code> prefix and
+                    checksum).</dd>
+                <dt>payload.messageType <span class="property-type">string</span></dt>
+                <dd>The sentence type, echoed back as it was supplied.</dd>
+                <dt>payload.input <span class="property-type">object</span></dt>
+                <dd>The original input object.</dd>
+            </dl>
+        </li>
+        <li>Error
+            <dl class="message-properties">
+                <dt>payload.error <span class="property-type">Error | string</span></dt>
+                <dd>The exception or reason for the failure. Unknown
+                    <code>messageType</code> values, missing input fields, and
+                    encoder errors all surface here.</dd>
+                <dt>payload.input <span class="property-type">any</span></dt>
+                <dd>The offending input.</dd>
+                <dt>payload.inputString <span class="property-type">string</span></dt>
+                <dd>String representation of the input for logging.</dd>
+            </dl>
+        </li>
+    </ol>
 </script>

package/ntrip/99-ntrip.js

@@ -1,27 +1,30 @@
 /**
-* Created by Karl-Heinz Wind
-**/
+ * Created by Karl-Heinz Wind
+ **/
 
 module.exports = function (RED) {
-    "use strict";
-    	
+    'use strict';
+
     const pkg = require('./../package.json');
     RED.log.info('node-red-contrib-ntrip version: v' + pkg.version);
 
     const NtripClientNode = require('./nodes/ntrip-client-node.js')(RED);
-    RED.nodes.registerType("NtripClient", NtripClientNode, {
+    RED.nodes.registerType('NtripClient', NtripClientNode, {
         credentials: {
-            username: { type: "text" },
-            password: { type: "password" },
-        }
+            username: { type: 'text' },
+            password: { type: 'password' },
+        },
     });
 
     const RtcmDecoderNode = require('./nodes/rtcm-decoder-node.js')(RED);
-    RED.nodes.registerType("RtcmDecoder", RtcmDecoderNode);
+    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);
+    RED.nodes.registerType('NmeaDecoder', NmeaDecoderNode);
 
     const NmeaEncoderNode = require('./nodes/nmea-encoder-node.js')(RED);
-    RED.nodes.registerType("NmeaEncoder", NmeaEncoderNode);
-}
+    RED.nodes.registerType('NmeaEncoder', NmeaEncoderNode);
+};

package/ntrip/lib/ntrip-client.js

@@ -6,9 +6,18 @@ const net = require('net');
 
 // Orginal class is extended to be able to send data to the caster.
 class NtripClientUploader extends NtripClient {
-    constructor(options) {  
+    constructor(options) {
         super(options);
         this.authmode = options.authmode || 'legacy';
+
+        // Reject CR/LF in user-supplied fields that are interpolated into the
+        // handshake string, to prevent header injection.
+        for (const field of ['mountpoint', 'username', 'password']) {
+            const value = this[field];
+            if (typeof value === 'string' && /[\r\n]/.test(value)) {
+                throw new Error('Invalid character in ' + field + ': CR/LF not allowed');
+            }
+        }
     }
 
     _connect() {
@@ -19,12 +28,12 @@ class NtripClientUploader extends NtripClient {
         // init connection of client
         this.client = net.createConnection({
             host: this.host,
-            port: this.port
+            port: this.port,
         });
 
         // on timeout event
         this.client.on('timeout', () => {
-            this._onError('socket timeouted');
+            this._onError('socket timeout');
         });
 
         // on connect event
@@ -36,23 +45,19 @@ class NtripClientUploader extends NtripClient {
             const host = this.host;
             const port = this.port;
             const authmode = this.authmode;
-            const authorization = Buffer.from(
-                username + ':' + password,
-                'utf8'
-            ).toString('base64');
-        
+            const authorization = Buffer.from(username + ':' + password, 'utf8').toString('base64');
+
             let data;
             switch (authmode) {
-                case 'legacy': // Legacy --> rtk2Go accepts this. 
+                case 'legacy': // Legacy --> rtk2Go accepts this.
                     if (username === '' && password === '') {
                         data = `SOURCE ${mountpoint}\r\n\r\n`;
-                    }
-                    else {
-                        data = `SOURCE ${password} /${mountpoint}\r\nSource-Agent: NTRIP ${username}\r\n\r\n`;     
+                    } else {
+                        data = `SOURCE ${password} /${mountpoint}\r\nSource-Agent: NTRIP ${username}\r\n\r\n`;
                     }
                     break;
                 case 'hybrid': // hybrid (legacy + http auth) --> SNIP accepts this.
-                    data = `SOURCE ${mountpoint}\r\nAuthorization: Basic ${authorization}\r\n\r\n`;      
+                    data = `SOURCE ${mountpoint}\r\nAuthorization: Basic ${authorization}\r\n\r\n`;
                     break;
                 case 'ntripv1': // NTRIP V1 POST
                     data = `POST /${mountpoint} HTTP/1.0\r\nUser-Agent: NTRIP ${userAgent}\r\nAuthorization: Basic ${authorization}\r\nContent-Type: gnss/data\r\n\r\n`;
@@ -61,7 +66,7 @@ class NtripClientUploader extends NtripClient {
                     data = `POST /${mountpoint} HTTP/1.1\r\nHost: ${host}:${port}\r\nUser-Agent: NTRIP ${userAgent}\r\nAuthorization: Basic ${authorization}\r\nNtrip-Version: Ntrip/2.0\r\nContent-Type: gnss/data\r\nConnection: keep-alive\r\n\r\n`;
                     break;
                 default:
-                    throw new Error("Auth mode is not supported " + authmode);
+                    throw new Error('Auth mode is not supported ' + authmode);
             }
 
             this.client.write(data);
@@ -93,14 +98,14 @@ class NtripClientUploader extends NtripClient {
 }
 
 function createDownloader(options) {
-    return new NtripClient(options)
+    return new NtripClient(options);
 }
 
 function createUploader(options) {
-    return new NtripClientUploader(options)
+    return new NtripClientUploader(options);
 }
 
 module.exports = {
     createDownloader,
-    createUploader
-};
+    createUploader,
+};

package/ntrip/nodes/nmea-decoder-node.js

@@ -9,54 +9,97 @@ module.exports = function (RED) {
         node.nmeaMessagesReceived = 0;
         node.invalidMessagesReceived = 0;
 
-        this.on('input', function (msg) {
+        function updateStatus() {
+            node.status({
+                fill: 'green',
+                shape: 'ring',
+                text: 'NMEA: ' + node.nmeaMessagesReceived + ' Invalid: ' + node.invalidMessagesReceived,
+            });
+        }
 
-            let buffer = msg.payload.nmeaMessage ?? msg.payload;
-            if(Buffer.isBuffer(buffer)){
-                buffer = buffer.toString('utf8');
-            }
-            
-            try
-            {   
-                let nmeaMessage = NmeaTransport.decode(buffer);   
+        function decodeOne(sentence, rawInput, rawString) {
+            try {
+                let nmeaMessage = NmeaTransport.decode(sentence);
                 let messageType = nmeaMessage.constructor.name.replace('NmeaMessage', '').toUpperCase();
 
-                let msg = {
-                    payload : {
-                        messageType : messageType,
-                        nmeaMessage : nmeaMessage,   
-                        input : buffer
+                node.send([
+                    {
+                        payload: {
+                            messageType: messageType,
+                            nmeaMessage: nmeaMessage,
+                            input: sentence,
+                        },
                     },
-                };
-
-                node.send([msg, null]);
+                    null,
+                ]);
                 node.nmeaMessagesReceived++;
+            } catch (ex) {
+                node.send([
+                    null,
+                    {
+                        payload: {
+                            error: ex,
+                            input: rawInput,
+                            inputString: rawString,
+                        },
+                    },
+                ]);
+                node.invalidMessagesReceived++;
+            }
+        }
+
+        this.on('input', function (msg) {
+            if (msg.payload === undefined || msg.payload === null) {
+                return;
             }
-            catch(ex)
-            {
-                let msg = {
-                    payload : {
-                        error : ex,
-                        input : buffer,
-                        inputString : buffer.toString()
-                    }
-                };
-                node.send([null, msg]);
+
+            // rawInput is the value the user provided (Buffer, string, ...).
+            // Keep it untouched so the error output can return it as-is.
+            let rawInput = typeof msg.payload === 'object' && msg.payload.nmeaMessage !== undefined ? msg.payload.nmeaMessage : msg.payload;
+
+            let rawString;
+            if (Buffer.isBuffer(rawInput)) {
+                rawString = rawInput.toString('utf8');
+            } else if (typeof rawInput === 'string') {
+                rawString = rawInput;
+            } else {
+                node.send([
+                    null,
+                    {
+                        payload: {
+                            error: 'Payload is neither string nor Buffer',
+                            input: rawInput,
+                            inputString: String(rawInput),
+                        },
+                    },
+                ]);
                 node.invalidMessagesReceived++;
+                updateStatus();
+                return;
             }
 
-            node.status({
-                fill: 'green',
-                    shape: 'ring',
-                    text: 'NMEA: ' + node.nmeaMessagesReceived + ' Invalid: ' + node.invalidMessagesReceived,
-                });
+            // A single chunk may carry several sentences delimited by \r\n.
+            let sentences = rawString.split(/\r?\n/);
+            let any = false;
+            for (let i = 0; i < sentences.length; i++) {
+                let s = sentences[i].trim();
+                if (s.length === 0) {
+                    continue;
+                }
+                decodeOne(s, rawInput, rawString);
+                any = true;
+            }
+
+            if (any) {
+                updateStatus();
+            }
         });
 
-        this.on('close', function(done) {
+        this.on('close', function (done) {
             node.status({});
             done();
         });
     }
 
     return NmeaDecoderNode;
-};
+};