TTN Smart Sensor (Kamstrup)

Codec Preview

/** * THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ // Primary VIF table according to Table 10 in 13757-3:2018 var PriVifTable = { 0x10: { type: "Volume", unit: "m3", resolution: 1E-6, ConversionType: "B" }, 0x11: { type: "Volume", unit: "m3", resolution: 1E-5, ConversionType: "B" }, 0x12: { type: "Volume", unit: "m3", resolution: 1E-4, ConversionType: "B" }, 0x13: { type: "Volume", unit: "m3", resolution: 1E-3, ConversionType: "B" }, 0x14: { type: "Volume", unit: "m3", resolution: 1E-2, ConversionType: "B" }, 0x15: { type: "Volume", unit: "m3", resolution: 1E-1, ConversionType: "B" }, 0x16: { type: "Volume", unit: "m3", resolution: 1E-0, ConversionType: "B" }, 0x17: { type: "Volume", unit: "m3", resolution: 1E+1, ConversionType: "B" }, 0x38: { type: "Volume flow", unit: "m3/h", resolution: 1E-6, ConversionType: "B" }, 0x39: { type: "Volume flow", unit: "m3/h", resolution: 1E-5, ConversionType: "B" }, 0x3A: { type: "Volume flow", unit: "m3/h", resolution: 1E-4, ConversionType: "B" }, 0x3B: { type: "Volume flow", unit: "m3/h", resolution: 1E-3, ConversionType: "B" }, 0x3C: { type: "Volume flow", unit: "m3/h", resolution: 1E-2, ConversionType: "B" }, 0x3D: { type: "Volume flow", unit: "m3/h", resolution: 1E-1, ConversionType: "B" }, 0x3E: { type: "Volume flow", unit: "m3/h", resolution: 1E-0, ConversionType: "B" }, 0x3F: { type: "Volume flow", unit: "m3/h", resolution: 1E+1, ConversionType: "B" }, 0x58: { type: "Flow temperature", unit: "C", resolution: 1E-3, ConversionType: "B" }, 0x59: { type: "Flow temperature", unit: "C", resolution: 1E-2, ConversionType: "B" }, 0x5A: { type: "Flow temperature", unit: "C", resolution: 1E-1, ConversionType: "B" }, 0x5B: { type: "Flow temperature", unit: "C", resolution: 1E-0, ConversionType: "B" }, 0x64: { type: "External temperature", unit: "C", resolution: 1E-3, ConversionType: "B" }, 0x65: { type: "External temperature", unit: "C", resolution: 1E-2, ConversionType: "B" }, 0x66: { type: "External temperature", unit: "C", resolution: 1E-1, ConversionType: "B" }, 0x67: { type: "External temperature", unit: "C", resolution: 1E-0, ConversionType: "B" }, 0x6C: { type: "Date/time", unit: "NA", resolution: 1, ConversionType: "G" }, 0x6D: { type: "Date/time", unit: "NA", resolution: 1, ConversionType: "F/J/I/M" }, }; // Manufacture specific VIFE var ManuVifeTable = { 0x25: { type: "Infocode", unit: "NA", resolution: 1, ConversionType: "D" }, 0x1C: { type: "ALD last day", unit: "NA", resolution: 1, ConversionType: "C" }, 0x16: { type: "Module type/config number", unit: "NA", resolution: 1, ConversionType: "C" }, 0x1B: { type: "ALD", unit: "NA", resolution: 1, ConversionType: "C" }, }; // Orthogonal VIFE table according to Table 15 in 13757-3:2018 var OrthoVifeTable = { 0x13: "Inverse Compact Profile", 0x3C: "Reverse", }; var InfocodeTable = { 0: "Dry", 1: "Reverse", 2: "Leak", 3: "Burst", 4: "Tamper", 5: "Low Battery", 6: "Low Ambient Temperature", 7: "High Ambient Temperature", }; /** * Parse Value Information Block (VIB) * @param VIBArray - Array containing the VIB * @returns - The VIB object */ function parseVIB(VIBArray) { var VIBObj = {}; if (VIBArray[0] == 0xFF) { if (VIBArray[1] in ManuVifeTable) { var tempObj = ManuVifeTable[VIBArray[1]]; VIBObj = { type: tempObj.type, unit: tempObj.unit, resolution: tempObj.resolution, ConversionType: tempObj.ConversionType }; // Copy instead of reference VIBObj.OrthoVife = "NA"; } else { return null; } } else if ((VIBArray[0] & 0x7F) in PriVifTable) { var tempObj = PriVifTable[VIBArray[0] & 0x7F]; VIBObj = { type: tempObj.type, unit: tempObj.unit, resolution: tempObj.resolution, ConversionType: tempObj.ConversionType }; // Copy instead of reference if ((VIBArray[0] & 0x80) != 0) { if (VIBArray[1] in OrthoVifeTable) { VIBObj.OrthoVife = OrthoVifeTable[VIBArray[1]]; } else { return null; } } else { VIBObj.OrthoVife = "NA"; } } else { // Unsupported VIF return null; } VIBObj.isProfileData = false; if (VIBObj.OrthoVife == "Inverse Compact Profile") { VIBObj.isProfileData = true; } return VIBObj; } /** * Reads an unsigned little endian integer from a buffer. * @param buffer - The input buffer. * @param offset - The byte index to start reading from. * @param byteLength - The number of bytes to read. * @returns - The unsigned integer value. */ function readUIntLE(buffer, offset, byteLength) { var value = 0; for (var i = 0; i < byteLength; i++) { value |= buffer[offset + i] << (8 * i); } return value >>> 0; // Ensure it's treated as an unsigned 32-bit integer } /** * Reads a signed little-endian integer using two's complement representation. * @param buffer - The input buffer. * @param offset - The byte index to start reading from. * @param byteLength - The number of bytes to read. * @returns - The signed integer value. */ function readIntLE(buffer, offset, byteLength) { var value = readUIntLE(buffer, offset, byteLength); var maxVal = 1 << (8 * byteLength - 1); // Two's complement sign bit position return (value & maxVal) ? value - (1 << (8 * byteLength)) : value; } /** * Mbus Type A - BCD to a number as described in EN13757-2018 Annex A. * @param buffer - Buffer input containing the BCD in little endian. * @param idx - Index at which the BCD starts. * @param size - Size in bytes of the BCD. * @returns - The converted number or undefined if invalid. */ function TypeA(buffer, idx, size) { var result = 0; var multiplier = 1; for (var j = idx; j < idx + size; j++) { var lsb = buffer[j] & 0xF; var msb = (buffer[j] >> 4) & 0xF; if (lsb > 9 || msb > 9) { // Invalid value return undefined; } result += lsb * multiplier; result += msb * multiplier * 10; multiplier *= 100; } return result; } /** * Mbus Type B - Binary signed integer as described in EN13757-2018 Annex A. * @param buffer - Buffer input containing value to convert in little endian. * @param idx - Index at which the value starts. * @param size - Size in bytes. * @returns - The converted number or undefined if invalid. */ function TypeB(buffer, idx, size) { var invalidValues = { 1: -0x80, 2: -0x8000, 3: -0x800000, 4: -0x80000000, 6: -0x800000000000 }; var result = readIntLE(buffer, idx, size); if (result == invalidValues[size]) { result = undefined; } return result; } /** * Mbus Type C - Binary unsigned integer as described in EN13757-2018 Annex A. * @param buffer - Buffer input containing value to convert in little endian. * @param idx - Index at which the value starts. * @param size - Size in bytes. * @returns - The converted number or undefined if invalid. */ function TypeC(buffer, idx, size) { var invalidValues = { 1: 0xFF, 2: 0xFFFF, 3: 0xFFFFFF, 4: 0xFFFFFFFF, 6: 0xFFFFFFFFFFFF }; var result = readUIntLE(buffer, idx, size); if (result == invalidValues[size]) { result = undefined; } return result; } /** * Mbus Type D - Boolean array as described in EN13757-2018 Annex A. * @param buffer - Buffer input containing value to convert in little endian. * @param idx - Index at which the value starts. * @param size - Size in bytes. * @returns - The converted number. */ function TypeD(buffer, idx, size) { return readUIntLE(buffer, idx, size); } /** * Mbus Type F - Date and Time (CP32) as described in EN13757-2018 Annex A. * @param buffer - Buffer input containing value to convert in little endian. * @param idx - Index at which the value starts. * @param size - Size in bytes. * @returns - Timestamp. */ function TypeF(buffer, idx, size) { var data = readUIntLE(buffer, idx, size); if ((data & 0x00000080) != 0) { return undefined; } var minutes = data & 0x0000003f; var hours = (data >> 8) & 0x0000001f; var days = (data >> 16) & 0x0000001f; var months = (data >> 24) & 0x0000000f; var years = (data >> 21) & 0x00000007; years += ((data >> 28) & 0x0000000f) << 3; var hYears = (data >> 13) & 0x00000003; years += 1900 + (hYears * 100); return new Date(Date.UTC(years, months - 1, days, hours, minutes)); } /** * Mbus Type G - Date as described in EN13757-2018 Annex A. * @param buffer - Buffer input containing value to convert in little endian. * @param idx - Index at which the value starts. * @param size - Size in bytes. * @returns - Timestamp. */ function TypeG(buffer, idx, size) { var data = readUIntLE(buffer, idx, size); if (data == 0xFFFF) { return undefined; } var days = (data >> 0) & 0x001f; var months = (data >> 8) & 0x000f; var years = 2000 + ((data >> 5) & 0x0007); years += ((data >> 12) & 0x000f) << 3; return new Date(Date.UTC(years, months - 1, days)); } /** * Mbus Type I - Date and Time (CP48) as described in EN13757-2018 Annex A. * @param buffer - Buffer input containing value to convert in little endian. * @param idx - Index at which the value starts. * @param size - Size in bytes. * @returns - Timestamp. */ function TypeI(buffer, idx, size) { if ((buffer[idx + 1] & 0x80) != 0) { return undefined; } var seconds = buffer[idx] & 0x3f; var minutes = buffer[idx + 1] & 0x3f; var hours = buffer[idx + 2] & 0x1f; var days = buffer[idx + 3] & 0x1f; var months = buffer[idx + 4] & 0xf; var years = (buffer[idx + 3] >> 5) & 0x7; years += ((buffer[idx + 4] >> 4) & 0xf) << 3; years += 2000; return new Date(Date.UTC(years, months - 1, days, hours, minutes, seconds)); } /** * Inverse Compact Profile - Parsing of Inverse Compact Profile as described in EN13757-2018 Annex F. * @param buffer - The input buffer. * @param idx - The index at which Inverse Compact Profile header starts (byte after LVAR). * @param size - The size of the inverse compact profile (equal to LVAR). * @returns - An object containing the profile data. */ function InverseCompactProfile(buffer, idx, size) { var result = {}; var spacingControl = buffer[idx]; idx++; result.spacingValue = buffer[idx]; idx++; var elementSize = spacingControl & 0x0F; result.spacingUnit = (spacingControl >> 4) & 0x03; result.incMode = (spacingControl >> 6) & 0x03; result.profileValues = []; if (elementSize < 1 || elementSize > 4 || result.incMode == 0) { return null; } for (var k = 0; k < size - 2; k += elementSize) { if (result.incMode == 0x3) { // Signed difference - TypeB result.profileValues.push(TypeB(buffer, idx, elementSize)); } else { // Unsigned increments or decrements - TypeC result.profileValues.push(TypeC(buffer, idx, elementSize)); } idx += elementSize; } return result; } /** * GetNextTimestamp - Calculate next timestamp for delta values based on spacing unit/value as described in EN13757-2018 Annex F. * @param timestamp - The timestamp to operate on. * @param spacingUnit - The spacing unit as described in EN13757-2018 Annex F. * @param spacingValue - The spacing value as described in EN13757-2018 Annex F. * @returns - The status of the operation. */ function getNextTimestamp(timestamp, spacingUnit, spacingValue) { if (spacingValue > 0 && spacingValue < 251) { if (spacingUnit == 0) { // Seconds timestamp.setUTCSeconds(timestamp.getUTCSeconds() - spacingValue); } else if (spacingUnit == 1) { // Minutes timestamp.setUTCMinutes(timestamp.getUTCMinutes() - spacingValue); } else if (spacingUnit == 2) { // Hours timestamp.setUTCHours(timestamp.getUTCHours() - spacingValue); } else if (spacingUnit == 3) { // Days/Months timestamp.setUTCDate(timestamp.getUTCDate() - spacingValue); } } else if (spacingValue == 254 && spacingUnit == 3) { timestamp.setUTCMonth(timestamp.getUTCMonth() - 1); } else if (spacingValue == 254 && spacingUnit == 2) { timestamp.setUTCMonth(timestamp.getUTCMonth() - 3); } else if (spacingValue == 254 && spacingUnit == 1) { timestamp.setUTCMonth(timestamp.getUTCMonth() - 6); } else { return false; } return true; } /** * Normalize a number based on the given resolution. * This function multiplies the number by the resolution and rounds it to avoid floating-point precision issues. * @param number - The number to normalize. * @param resolution - The resolution to use for normalization. * @returns - The normalized number. */ function normalize(number, resolution) { return Math.round(number * resolution * 1e10) / 1e10; } /** * Decode uplink * @param {Object} input - An object provided by the IoT Flow framework * @param {number[]} input.bytes - Array of bytes represented as numbers as it has been sent from the device * @param {number} input.fPort - The Port Field on which the uplink has been sent * @param {Date} input.recvTime - The uplink message time recorded by the LoRaWAN network server * @returns {DecodedUplink} - The decoded object */ function decodeUplink(input) { var result = { data: {}, errors: [], warnings: [] }; var i = 0; var configfield = 0; var raw = input.bytes; ////////////////// TPL according to EN 13757-7 ////////////////// if (raw.length < 1) { result.errors.push("Invalid uplink payload: Could not retrieve CI field"); return result; } var CI = raw[i]; i++; if (CI == 0x7A) { // Short data header if (raw.length < i + 4) { result.errors.push("Invalid uplink payload: Could not retrieve TPL layer"); return result; } i += 2; // ACC, STS configfield = raw[i] | (raw[i + 1] << 8); i += 2; } else if (CI == 0x72) { // Long data header if (raw.length < i + 12) { result.errors.push("Invalid uplink payload: Could not retrieve TPL layer"); return result; } i += 10; // IdentNo, Manu, Ver, DevType, ACC, STS configfield = raw[i] | (raw[i + 1] << 8); i += 2; } else if (CI == 0x78) { // No data header // Do nothing } else { // Unsupported header result.errors.push("Invalid uplink payload: Invalid CI in TPL layer"); return result; } if ((configfield & 0x1F00) != 0x0) { // Security mode different from 0 result.errors.push("Invalid uplink payload: MBus TPL encryption is not supported"); return result; } ////////////////// APL according to EN 13757-3 ////////////////// var temp; var mbusRecords = []; while (i < raw.length) { // Check for more records var record = { dib: {}, vib: {}, data: {}, profileData: {}, }; temp = raw[i]; i++; if (temp == 0x2F) { // Skip Filler bytes } else if (temp == 0x0F || temp == 0x1F || temp == 0x7F) { // Unsupported special DIF functions result.errors.push("Invalid uplink payload: Unsupported special DIF function"); return result; } else { // No special function - continue // DIB record.dib.datafield = temp & 0xF; record.dib.functionfield = (temp & 0x30) >> 4; record.dib.storagenumber = (temp & 0x40) >> 6; var snBitShift = 1; while ((temp & 0x80) != 0 && i < raw.length) { // Extension temp = raw[i]; i++; record.dib.storagenumber += ((temp & 0xF) << snBitShift); snBitShift += 4; } // VIB temp = raw[i]; i++; var vibBytes = [temp]; while ((temp & 0x80) != 0 && i < raw.length) { // Extension temp = raw[i]; i++; vibBytes.push(temp); } // Parse VIF code record.vib = parseVIB(vibBytes); if (record.vib == null) { // Unsupported special VIB functions result.errors.push("Invalid uplink payload: Unsupported VIB"); return result; } // Data var sizeByte = 0; var bcd = false; var lvar = false; switch (record.dib.datafield) { case 0: case 0x8: // No data sizeByte = 0; break; case 0x9: bcd = true; case 0x1: sizeByte = 1; break; case 0xA: bcd = true; case 0x2: sizeByte = 2; break; case 0xB: bcd = true; case 0x3: sizeByte = 3; break; case 0xC: bcd = true; case 0x4: case 0x5: sizeByte = 4; break; case 0xE: bcd = true; case 0x6: sizeByte = 6; break; case 0x7: sizeByte = 8; break; case 0xD: sizeByte = 1; // Lvar # bytes lvar = true; break; } if (raw.length < i + sizeByte || sizeByte > 6) { result.errors.push("Invalid uplink payload: Not enough bytes for datafield or datafield is larger than 6 bytes"); return result; } if (!lvar) { if (bcd) { record.data = TypeA(raw, i, sizeByte); } else { if (record.vib.ConversionType == "C") { record.data = TypeC(raw, i, sizeByte); } else if (record.vib.ConversionType == "B") { record.data = TypeB(raw, i, sizeByte); } else if (record.vib.ConversionType == "D") { record.data = TypeD(raw, i, sizeByte); } else if (record.vib.ConversionType == "G") { record.data = TypeG(raw, i, sizeByte); } else if (record.vib.ConversionType == "F/J/I/M") { if (sizeByte == 4) { record.data = TypeF(raw, i, sizeByte); } else if (sizeByte == 6) { record.data = TypeI(raw, i, sizeByte); } } } i += sizeByte; } else { // Lvar var nbBytes = raw[i]; i++; if (raw.length < i + nbBytes || nbBytes < 3) { result.errors.push("Invalid uplink payload: Not enough bytes for LVAR"); return result; } if (!record.vib.isProfileData) { result.errors.push("Invalid uplink payload: LVAR that is not Inverse Compact Profile is not supported"); return result; } record.profileData = InverseCompactProfile(raw, i, nbBytes); i += nbBytes; if (record.profileData == null) { result.errors.push("Invalid uplink payload: Could not parse Inverse Compact Profile"); return result; } } mbusRecords.push(record); } } // Append functionfield and orthogonal VIFE to type for (var l = 0; l < mbusRecords.length; l++) { var functionFieldText = ""; if (mbusRecords[l].vib.OrthoVife != "NA" && mbusRecords[l].vib.OrthoVife != "Inverse Compact Profile") { // Append orthogonal VIFE in beginning of type, e.g., "Reverse "flow. mbusRecords[l].vib.type = mbusRecords[l].vib.OrthoVife + " " + mbusRecords[l].vib.type; } switch (mbusRecords[l].dib.functionfield) { case 0x0: functionFieldText = ""; // Instantaneous value is left untouched break; case 0x1: functionFieldText = "Max "; // Instantaneous value is left untouched break; case 0x2: functionFieldText = "Min "; // Instantaneous value is left untouched break; case 0x3: functionFieldText = "Error state "; // Instantaneous value is left untouched break; } // Append functionfield in beginning of type, e.g., "Max "flow. mbusRecords[l].vib.type = functionFieldText + mbusRecords[l].vib.type; } // Retrieve timestamps var timestamps = {}; for (var k = 0; k < mbusRecords.length; k++) { if (mbusRecords[k].vib.type == "Date/time") { if (mbusRecords[k].data !== undefined) { timestamps[mbusRecords[k].dib.storagenumber] = mbusRecords[k].data; } else { result.warnings.push("Invalid value among timestamps"); } } } // Generate the output data result.data.values = []; for (var p = 0; p < mbusRecords.length; p++) { var type; var value = null; var unit; var timestamp = null; var currentRecord = mbusRecords[p]; // Add records to values array if (currentRecord.vib.type == "Date/time") { // Skip timestamps as they are mapped directly onto records // Skip } else if (currentRecord.vib.type.includes("Infocode") && currentRecord.data !== undefined) { // Special infocode handling for (var j = 0; j < Object.keys(InfocodeTable).length; j++) { type = InfocodeTable[j]; value = (currentRecord.data & (1 << j)) != 0; unit = currentRecord.vib.unit; if (currentRecord.dib.storagenumber in timestamps) { if (timestamps[currentRecord.dib.storagenumber] instanceof Date) { timestamp = timestamps[currentRecord.dib.storagenumber].toISOString().replace("Z",""); } } result.data.values.push({ Type: type, Value: value, Unit: unit, Timestamp: timestamp }); } } else if (!currentRecord.vib.isProfileData) { // Regular values type = currentRecord.vib.type; unit = currentRecord.vib.unit; // If invalid ALD if (type === "ALD last day" && currentRecord.data == 4095) { currentRecord.data = undefined; } // Normalize and add data if it is not undefined if (currentRecord.data !== undefined) { value = normalize(currentRecord.data, currentRecord.vib.resolution); } else { unit = "Invalid"; result.warnings.push("Invalid value among data"); } // Add timestamp if (currentRecord.dib.storagenumber in timestamps) { if (timestamps[currentRecord.dib.storagenumber] instanceof Date) { timestamp = timestamps[currentRecord.dib.storagenumber].toISOString().replace("Z",""); } } result.data.values.push({ Type: type, Value: value, Unit: unit, Timestamp: timestamp }); if (type === "Volume") { // Special handling for latest volume result.data.latestVolume = value; } } else { // Profile values type = currentRecord.vib.type; unit = currentRecord.vib.unit; // Find base value where storage number and vib type, unit and resolution fits var baserecord = mbusRecords.find(item => item.vib.type === type && item.vib.unit === unit && item.dib.storagenumber === currentRecord.dib.storagenumber && item.vib.resolution === currentRecord.vib.resolution && item.vib.isProfileData !== currentRecord.vib.isProfileData); if (baserecord === undefined || baserecord.data === undefined) { result.errors.push("Invalid uplink payload: Could not find base value for profile data"); return result; } var tempVal = baserecord.data; // Find base time if (currentRecord.dib.storagenumber in timestamps) { timestamp = timestamps[currentRecord.dib.storagenumber]; } else { result.errors.push("Invalid uplink payload: Could not find base time for profile data"); return result; } var ts = new Date(timestamp.getTime()); // Clone timestamp // Loop through delta values for (var m = 0; m < currentRecord.profileData.profileValues.length; m++) { var deltavalue = currentRecord.profileData.profileValues[m]; var status = getNextTimestamp(ts, currentRecord.profileData.spacingUnit, currentRecord.profileData.spacingValue); if (deltavalue === undefined || status == false || isNaN(ts)) { result.warnings.push("Invalid value among profile values or timestamps for profile values"); break; } // Value if (currentRecord.profileData.incMode == 2) { tempVal += deltavalue; } else { tempVal -= deltavalue; } value = normalize(tempVal, currentRecord.vib.resolution); // Timestamp timestamp = ts.toISOString().replace("Z",""); result.data.values.push({ Type: type, Value: value, Unit: unit, Timestamp: timestamp }); } } } return result; }