@lora-contrib/node-red-contrib-payload-parser/nodes/node-red-contrib-payload-parser/payload-parser.js

Parse Lora payload

const convert = require('./helper/conversion');

module.exports = function (RED) {
    function PayloadParserNode(config) {
        RED.nodes.createNode(this, config);
        let node = this;

        try {
            this.frames = JSON.parse(config.frames);
        } catch (error) {
            this.frames = {};
        }

        node.on('input', function (msg, send, done) {
            var headers = Object.getOwnPropertyNames(this.frames);
            headers.sort((a, b) => {
                if (a.length == b.length) {
                    return a - b;
                }
                else {
                    return b.length - a.length;
                }
            });

            var dataBuffer = Buffer.from(msg.payload.data, 'hex');
            var frameDefinition = undefined;
            for (const header of headers) {
                if (header === dataBuffer.toString('hex', 0, header.length / 2)) {
                    frameDefinition = this.frames[header];
                    break;
                }
            }

            if (frameDefinition) {
                var frame = {
                    "name": frameDefinition.name,
                    "channels": {}
                };
                for (const channelDefinition of frameDefinition.channels) {
                    if (!frame.channels.hasOwnProperty(channelDefinition.name)) {
                        frame.channels[channelDefinition.name] = {
                            "unit": channelDefinition.unit,
                            "values": []
                        };
                    }

                    let buffer = Buffer.alloc(channelDefinition.end - channelDefinition.start + 1);
                    dataBuffer.copy(buffer, 0, channelDefinition.start - 1, channelDefinition.end);

                    bufferValue = convert.converter(buffer, channelDefinition.type);

                    let value = bufferValue;
                    try {
                        if (bufferValue !== null && channelDefinition.calcul) {
                            eval("var func = function(x) { return " + channelDefinition.calcul + "; }");
                            value = func(bufferValue);
                        }
                    } catch (error) { }

                    frame.channels[channelDefinition.name].values.push({
                        "raw_value": bufferValue,
                        "decoded_value": value
                    });

                    //console.error('<---------------------------------');
                    //console.error(dataBuffer);
                    //console.error(buffer);
                    //console.error(channelDefinition.type + ' - ' + bufferValue + ' - ' + value);
                    //console.error(channelDefinition);
                    //console.error('--------------------------------->');
                }
            }

            msg.payload.frame = frame;
            send(msg);

            if (done) {
                done();
            }
        });
    }

    RED.nodes.registerType("payload-parser", PayloadParserNode);
}