Water Level Sensor (LoRaWAN)

/* Helper functions used by this parser */
function signed(val, bits) {
    if ((val & 1 << (bits-1)) > 0) { // value is negative (16bit 2's complement)
        val = (~val & ((1 << bits) - 1)) + 1; // invert all bits & add 1 => now positive value
        val = val * -1;
    }
    return val;
}
function uint40_BE(bytes, idx) {
    bytes = bytes.slice(idx || 0);
    return bytes[0] << 32 |
        bytes[1] << 24 | bytes[2] << 16 | bytes[3] << 8 | bytes[4] << 0;
}
function uint32_BE(bytes, idx) {
    bytes = bytes.slice(idx || 0);
    return bytes[0] << 24 | bytes[1] << 16 | bytes[2] << 8 | bytes[3] << 0;
}
function uint16_BE(bytes, idx) {
    bytes = bytes.slice(idx || 0);
    return bytes[0] << 8 | bytes[1] << 0;
}
function uint32_LE(bytes, idx) {
    bytes = bytes.slice(idx || 0);
    return bytes[0] << 0 | bytes[1] << 8 | bytes[2] << 16 | bytes[3] << 24;
}
function uint16_LE(bytes, idx) {
    bytes = bytes.slice(idx || 0);
    return bytes[0] << 0 | bytes[1] << 8;
}
function int40_BE(bytes, idx) {
    return signed(uint40_BE(bytes, idx), 40);
}
function int32_BE(bytes, idx) {
    return signed(uint32_BE(bytes, idx), 32);
}
function int16_BE(bytes, idx) {
    return signed(uint16_BE(bytes, idx), 16);
}
function int32_LE(bytes, idx) {
    return signed(uint32_LE(bytes, idx), 32);
}
function int16_LE(bytes, idx) {
    return signed(uint16_LE(bytes, idx), 16);
}
function float32(bytes) {
    var sign = (bytes & 0x80000000) ? -1 : 1;
    var exponent = ((bytes >> 23) & 0xFF) - 127;
    var significand = (bytes & ~(-1 << 23));
    if (exponent === 128)
        return sign * ((significand) ? Number.NaN : Number.POSITIVE_INFINITY);
    if (exponent === -127) {
        if (significand === 0) return sign * 0.0;
        exponent = -126;
        significand /= (1 << 22);
    } else significand = (significand | (1 << 23)) / (1 << 23);
    return sign * significand * Math.pow(2, exponent);
}
function readVersion(bytes, i) {
    if (bytes.length < 3) {
        return null;
    }
    return "v" + bytes[i] + "." + bytes[i + 1] + "." + bytes[i + 2];
}

/* Port 1: Data */
function Decoder_Data(bytes) {
    return {
        pressure: float32(int32_LE(bytes, 0)),
        temp: int16_LE(bytes,4) / 100,
        voltage: int16_LE(bytes,6) / 1000,
    }
}

/**
 * Decode status/error codes from GPS-Tracker to human readable tags.
 */
function decode_status_code(code) {
    switch (code) {
        case 0:
            return "OK";
        case 101:
            return "PROBE_ERROR";
        default:
            return "UNKNOWN";
    }
}

/**
 * Decode reboot reason explaining last reboot of device.
 */
function decode_reboot_reason(code) {
    // STM reboot code from our HAL:
    switch (code) {
        case 1:
            return "LOW_POWER_RESET";
        case 2:
            return "WINDOW_WATCHDOG_RESET";
        case 3:
            return "INDEPENDENT_WATCHDOG_RESET";
        case 4:
            return "SOFTWARE_RESET";
        case 5:
            return "POWER_ON_RESET";
        case 6:
            return "EXTERNAL_RESET_PIN_RESET";
        case 7:
            return "OBL_RESET";
        default:
            return "UNKNOWN";
    }
}

/* Port 64: Status */
function Decoder_Status(bytes) {
    var firmware = String.fromCharCode.apply(null, bytes.slice(0, 3));
    var version = readVersion(bytes, 3);
    var status_code = bytes[6];
    var status_text = decode_status_code(status_code);
    var reboot_code = bytes[7];
    var reboot_reason = decode_reboot_reason(reboot_code);
    var final_code = bytes[8];
    var vcc = (int16_BE(bytes, 9) / 1000) || 0.0;
    var temp = (int16_BE(bytes, 11) / 10) || -0x8000;
    var app_data = bytes.slice(13);

    return {
        "firmware": firmware,
        "version": version,
        "status_code": status_code,
        "status_text": status_text,
        "reboot_code": reboot_code,
        "reboot_reason": reboot_reason,
        "final_code": final_code,
        "temperature": temp,
        "voltage": vcc,
        "app_data": app_data
    };
}

// TTN compatible decoder function:
function Decoder(bytes, port) {
    // Decode an uplink message from a buffer
    // (array) of bytes to an object of fields
    switch (port) {
        case 1:
            // date message:
            return Decoder_Data(bytes);
        case 64:
            // lobaro unified status telegram
            return Decoder_Status(bytes);
        case 128:
        case 129:
        case 130:
        case 131:
            // remote config responses
            return {};
        default:
            // unsupported port:
            return null;
    }
}

function UpdateDevice(decoded) {
    if (!Device || !Device.setProperty) {
        // not in Lobaro Platform parser
        return;
    }
    var keys = ["firmware", "version", "status_code", "status_text", "reboot_code", "reboot_reason",
            "final_code", "final_words", "app_data", "temperature", "voltage"];
    for (var i=0; i< keys.length; i++) {
        var key = keys[i];
        if (decoded[key]) {
            Device.setProperty(key, decoded[key]);
        }
    }
}

// Wrapper for Lobaro Platform (not used in TTN)
function Parse(input) {
    // Decode an incoming message to an object of fields.
    var b = bytes(atob(input.data));
    // use TTN decoder:
    var decoded = Decoder(b, input.fPort);
    // Update values in device properties
    UpdateDevice(decoded);
    return decoded;
}