TEKTELIC - Panic Button Sensor

Codec Preview

/* This is an generic payload parser example. ** The code find the payload variable and parse it if exists. ** ** IMPORTANT: In most case, you will only need to edit the parsePayload function. ** ** Testing: ** You can do manual tests to this parse by using the Device Emulator. Copy and Paste the following code: ** [{ "variable": "payload", "value": "00 BA 70 00 00 00" }] ** ** The ignore_vars variable in this code should be used to ignore variables ** from the device that you don't want. */ // let payload = [{ variable: 'payload', value: '00 BA 70 00 00 00'.replace(/ /g, '') }]; // Add ignorable variables in this array. const ignore_vars = []; function toTagoFormat(object_item, serie, prefix = '') { const result = []; for (const key in object_item) { if (ignore_vars.includes(key)) continue; if (typeof object_item[key] === 'object') { result.push({ variable: object_item[key].variable || `${prefix}${key}`.toLowerCase(), value: object_item[key].value, serie: object_item[key].serie || serie, metadata: object_item[key].metadata, location: object_item[key].location, unit: object_item[key].unit, }); } else { result.push({ variable: `${prefix}${key}`.toLowerCase(), value: object_item[key], serie, }); } } return result; } function Decoder(bytes, port) { // bytes - Array of bytes (signed) function slice(a, f, t) { const res = []; for (let i = 0; i < t - f; i++) { res[i] = a[f + i]; } return res; } function extract_bytes(chunk, start_bit, end_bit) { const total_bits = end_bit - start_bit + 1; const total_bytes = total_bits % 8 === 0 ? to_uint(total_bits / 8) : to_uint(total_bits / 8) + 1; const offset_in_byte = start_bit % 8; const end_bit_chunk = total_bits % 8; const arr = new Array(total_bytes); for (byte = 0; byte < total_bytes; ++byte) { const chunk_idx = to_uint(start_bit / 8) + byte; let lo = chunk[chunk_idx] >> offset_in_byte; let hi = 0; if (byte < total_bytes - 1) { hi = (chunk[chunk_idx + 1] & ((1 << offset_in_byte) - 1)) << (8 - offset_in_byte); } else if (end_bit_chunk !== 0) { // Truncate last bits lo &= ((1 << end_bit_chunk) - 1); } arr[byte] = hi | lo; } return arr; } function apply_data_type(bytes, data_type) { output = 0; if (data_type === 'unsigned') { for (var i = 0; i < bytes.length; ++i) { output = (to_uint(output << 8)) | bytes[i]; } return output; } if (data_type === 'signed') { for (var i = 0; i < bytes.length; ++i) { output = (output << 8) | bytes[i]; } // Convert to signed, based on value size if (output > Math.pow(2, 8 * bytes.length - 1)) { output -= Math.pow(2, 8 * bytes.length); } return output; } if (data_type === 'bool') { return !(bytes[0] === 0); } if (data_type === 'hexstring') { return toHexString(bytes); } // Incorrect data type return null; } function decode_field(chunk, start_bit, end_bit, data_type) { chunk_size = chunk.length; if (end_bit >= chunk_size * 8) { return null; // Error: exceeding boundaries of the chunk } if (end_bit < start_bit) { return null; // Error: invalid input } arr = extract_bytes(chunk, start_bit, end_bit); return apply_data_type(arr, data_type); } decoded_data = {}; decoder = []; if (port === 10) { decoder = [ { key: [0x00, 0xBA], fn(arg) { decoded_data.battery_status_life = 2.5 + decode_field(arg, 0, 6, 'unsigned') * 0.01; decoded_data.battery_status_eos_alert = decode_field(arg, 7, 7, 'unsigned'); return 1; }, }, { key: [0x00, 0x04], fn(arg) { decoded_data.fsm_state = decode_field(arg, 0, 7, 'unsigned'); return 1; }, }, { key: [0x00, 0x67], fn(arg) { decoded_data.mcu_temperature = decode_field(arg, 0, 15, 'signed') * 0.1; return 2; }, }, { key: [0x00, 0x00], fn(arg) { decoded_data.acceleration_alarm = decode_field(arg, 0, 7, 'unsigned'); return 1; }, }, { key: [0x00, 0x71], fn(arg) { decoded_data.acceleration_xaxis = decode_field(arg, 0, 15, 'signed') * 0.001; decoded_data.acceleration_yaxis = decode_field(arg, 16, 31, 'signed') * 0.001; decoded_data.acceleration_zaxis = decode_field(arg, 32, 47, 'signed') * 0.001; return 6; }, }, ]; } if (port === 100) { decoder = [ { key: [0x00], fn(arg) { decoded_data.device_eui = decode_field(arg, 0, 63, 'hexstring'); return 8; }, }, { key: [0x01], fn(arg) { decoded_data.app_eui = decode_field(arg, 0, 63, 'hexstring'); return 8; }, }, { key: [0x02], fn(arg) { decoded_data.app_key = decode_field(arg, 0, 127, 'hexstring'); return 16; }, }, { key: [0x03], fn(arg) { decoded_data.device_address = decode_field(arg, 0, 31, 'hexstring'); return 4; }, }, { key: [0x04], fn(arg) { decoded_data.network_session_key = decode_field(arg, 0, 127, 'hexstring'); return 16; }, }, { key: [0x05], fn(arg) { decoded_data.app_session_key = decode_field(arg, 0, 127, 'hexstring'); return 16; }, }, { key: [0x10], fn(arg) { decoded_data.loramac_join_mode = decode_field(arg, 7, 7, 'unsigned'); return 2; }, }, { key: [0x11], fn(arg) { decoded_data.loramac_opts_confirm_mode = decode_field(arg, 8, 8, 'unsigned'); decoded_data.loramac_opts_sync_word = decode_field(arg, 9, 9, 'unsigned'); decoded_data.loramac_opts_duty_cycle = decode_field(arg, 10, 10, 'unsigned'); decoded_data.loramac_opts_adr = decode_field(arg, 11, 11, 'unsigned'); return 2; }, }, { key: [0x12], fn(arg) { decoded_data.loramac_dr_tx_dr_number = decode_field(arg, 0, 3, 'unsigned'); decoded_data.loramac_dr_tx_tx_power_number = decode_field(arg, 8, 11, 'unsigned'); return 2; }, }, { key: [0x13], fn(arg) { decoded_data.loramac_rx2_frequency = decode_field(arg, 0, 31, 'unsigned'); decoded_data.loramac_rx2_dr_number = decode_field(arg, 32, 39, 'unsigned'); return 5; }, }, { key: [0x20], fn(arg) { decoded_data.seconds_per_core_tick = decode_field(arg, 0, 31, 'unsigned'); return 4; }, }, { key: [0x21], fn(arg) { decoded_data.tick_per_battery = decode_field(arg, 0, 15, 'unsigned'); return 2; }, }, { key: [0x24], fn(arg) { decoded_data.tick_per_accelerometer = decode_field(arg, 0, 15, 'unsigned'); return 2; }, }, { key: [0x25], fn(arg) { decoded_data.tick_per_ble_default = decode_field(arg, 0, 15, 'unsigned'); return 2; }, }, { key: [0x26], fn(arg) { decoded_data.tick_per_ble_stillness = decode_field(arg, 0, 15, 'unsigned'); return 2; }, }, { key: [0x27], fn(arg) { decoded_data.tick_per_ble_mobility = decode_field(arg, 0, 15, 'unsigned'); return 2; }, }, { key: [0x28], fn(arg) { decoded_data.tick_per_temperature = decode_field(arg, 0, 15, 'unsigned'); return 2; }, }, { key: [0x2A], fn(arg) { decoded_data.mode_reed_event_type = decode_field(arg, 7, 7, 'unsigned'); decoded_data.mode_battery_voltage_report = decode_field(arg, 8, 8, 'unsigned'); decoded_data.mode_acceleration_vector_report = decode_field(arg, 9, 9, 'unsigned'); decoded_data.mode_temperature_report = decode_field(arg, 10, 10, 'unsigned'); decoded_data.mode_ble_report = decode_field(arg, 11, 11, 'unsigned'); return 2; }, }, { key: [0x2B], fn(arg) { decoded_data.event_type1_m_value = decode_field(arg, 0, 3, 'unsigned'); decoded_data.event_type1_n_value = decode_field(arg, 4, 7, 'unsigned'); return 1; }, }, { key: [0x2C], fn(arg) { decoded_data.event_type2_t_value = decode_field(arg, 0, 3, 'unsigned'); return 1; }, }, { key: [0x40], fn(arg) { decoded_data.accelerometer_xaxis_enabled = decode_field(arg, 0, 0, 'unsigned'); decoded_data.accelerometer_yaxis_enabled = decode_field(arg, 1, 1, 'unsigned'); decoded_data.accelerometer_zaxis_enabled = decode_field(arg, 2, 2, 'unsigned'); return 1; }, }, { key: [0x41], fn(arg) { decoded_data.sensitivity_accelerometer_sample_rate = decode_field(arg, 0, 2, 'unsigned') * 1; switch (decoded_data.sensitivity_accelerometer_sample_rate) { case 1: decoded_data.sensitivity_accelerometer_sample_rate = 1; break; case 2: decoded_data.sensitivity_accelerometer_sample_rate = 10; break; case 3: decoded_data.sensitivity_accelerometer_sample_rate = 25; break; case 4: decoded_data.sensitivity_accelerometer_sample_rate = 50; break; case 5: decoded_data.sensitivity_accelerometer_sample_rate = 100; break; case 6: decoded_data.sensitivity_accelerometer_sample_rate = 200; break; case 7: decoded_data.sensitivity_accelerometer_sample_rate = 400; break; default: // invalid value decoded_data.sensitivity_accelerometer_sample_rate = 0; break; } decoded_data.sensitivity_accelerometer_measurement_range = decode_field(arg, 4, 5, 'unsigned') * 1; switch (decoded_data.sensitivity_accelerometer_measurement_range) { case 0: decoded_data.sensitivity_accelerometer_measurement_range = 2; break; case 1: decoded_data.sensitivity_accelerometer_measurement_range = 4; break; case 2: decoded_data.sensitivity_accelerometer_measurement_range = 8; break; case 3: decoded_data.sensitivity_accelerometer_measurement_range = 16; break; default: decoded_data.sensitivity_accelerometer_measurement_range = 0; } return 1; }, }, { key: [0x42], fn(arg) { decoded_data.acceleration_alarm_threshold_count = decode_field(arg, 0, 15, 'unsigned'); return 2; }, }, { key: [0x43], fn(arg) { decoded_data.acceleration_alarm_threshold_period = decode_field(arg, 0, 15, 'unsigned'); return 2; }, }, { key: [0x44], fn(arg) { decoded_data.acceleration_alarm_threshold = decode_field(arg, 0, 15, 'unsigned') * 0.001; return 2; }, }, { key: [0x45], fn(arg) { decoded_data.acceleration_alarm_grace_period = decode_field(arg, 0, 15, 'unsigned'); return 2; }, }, { key: [0x46], fn(arg) { decoded_data.accelerometer_tx_report_periodic_enabled = decode_field(arg, 0, 0, 'unsigned'); decoded_data.accelerometer_tx_report_alarm_enabled = decode_field(arg, 1, 1, 'unsigned'); return 1; }, }, { key: [0x50], fn(arg) { decoded_data.ble_mode = decode_field(arg, 7, 7, 'unsigned'); return 1; }, }, { key: [0x51], fn(arg) { decoded_data.ble_scan_interval = decode_field(arg, 0, 15, 'unsigned') * 0.001; return 2; }, }, { key: [0x52], fn(arg) { decoded_data.ble_scan_window = decode_field(arg, 0, 15, 'unsigned') * 0.001; return 2; }, }, { key: [0x53], fn(arg) { decoded_data.ble_scan_duration = decode_field(arg, 0, 15, 'unsigned'); return 2; }, }, { key: [0x54], fn(arg) { decoded_data.ble_reported_devices = decode_field(arg, 0, 7, 'unsigned'); return 1; }, }, { key: [0x60], fn(arg) { decoded_data.temperature_sample_period_idle = decode_field(arg, 0, 31, 'unsigned'); return 4; }, }, { key: [0x61], fn(arg) { decoded_data.temperature_sample_period_active = decode_field(arg, 0, 31, 'unsigned'); return 4; }, }, { key: [0x62], fn(arg) { decoded_data.temperature_threshold_high = decode_field(arg, 0, 7, 'unsigned'); decoded_data.temperature_threshold_low = decode_field(arg, 8, 15, 'unsigned'); return 2; }, }, { key: [0x63], fn(arg) { decoded_data.temperature_threshold_enabled = decode_field(arg, 0, 0, 'unsigned'); return 1; }, }, { key: [0x71], fn(arg) { decoded_data.firmware_version_app_major_version = decode_field(arg, 0, 7, 'unsigned'); decoded_data.firmware_version_app_minor_version = decode_field(arg, 8, 15, 'unsigned'); decoded_data.firmware_version_app_revision = decode_field(arg, 16, 23, 'unsigned'); decoded_data.firmware_version_loramac_major_version = decode_field(arg, 24, 31, 'unsigned'); decoded_data.firmware_version_loramac_minor_version = decode_field(arg, 32, 39, 'unsigned'); decoded_data.firmware_version_loramac_revision = decode_field(arg, 40, 47, 'unsigned'); decoded_data.firmware_version_region = decode_field(arg, 48, 55, 'unsigned'); return 7; }, }, ]; } if (port === 25) { decoder = [ { key: [0x0A], fn(arg) { // RSSI to beacons let count = 0; for (let i = 0; i < arg.length * 8; i += 7 * 8) { dev_id = decode_field(arg, i, i + 6 * 8 - 1, 'hexstring'); decoded_data[dev_id] = decode_field(arg, i + 6 * 8, i + 7 * 8 - 1, 'signed'); count += 7; } return count; }, }, ]; } bytes = convertToUint8Array(bytes); decoded_data.raw = JSON.stringify(byteToArray(bytes)); decoded_data.port = port; for (let bytes_left = bytes.length; bytes_left > 0;) { let found = false; for (let i = 0; i < decoder.length; i++) { const item = decoder[i]; const key = item.key; const keylen = key.length; header = slice(bytes, 0, keylen); // Header in the data matches to what we expect if (is_equal(header, key)) { const f = item.fn; consumed = f(slice(bytes, keylen, bytes.length)) + keylen; bytes_left -= consumed; bytes = slice(bytes, consumed, bytes.length); found = true; break; } } if (found) { continue; } // Unable to decode -- headers are not as expected, send raw payload to the application! decoded_data = {}; decoded_data.raw = JSON.stringify(byteToArray(bytes)); decoded_data.port = port; return decoded_data; } // Converts value to unsigned function to_uint(x) { return x >>> 0; } // Checks if two arrays are equal function is_equal(arr1, arr2) { if (arr1.length != arr2.length) { return false; } for (let i = 0; i != arr1.length; i++) { if (arr1[i] != arr2[i]) { return false; } } return true; } function byteToArray(byteArray) { arr = []; for (let i = 0; i < byteArray.length; i++) { arr.push(byteArray[i]); } return arr; } function convertToUint8Array(byteArray) { arr = []; for (let i = 0; i < byteArray.length; i++) { arr.push(to_uint(byteArray[i]) & 0xff); } return arr; } function toHexString(byteArray) { const arr = []; for (let i = 0; i < byteArray.length; ++i) { arr.push((`0${(byteArray[i] & 0xFF).toString(16)}`).slice(-2)); } return arr.join(''); } return decoded_data; } // Remove unwanted variables. payload = payload.filter(x => !ignore_vars.includes(x.variable)); // Payload is an environment variable. Is where what is being inserted to your device comes in. // Payload always is an array of objects. [ { variable, value...}, {variable, value...} ...] const payload_raw = payload.find(x => x.variable === 'payload_raw' || x.variable === 'payload' || x.variable === 'data'); const port = payload.find(x => x.variable === 'port' || x.variable === 'fport'); if (payload_raw) { // Get a unique serie for the incoming data. const { value, time } = payload_raw; let { serie } = payload_raw; serie = new Date().getTime(); // Parse the payload_raw to JSON format (it comes in a String format) if (value) { payload = payload.concat(toTagoFormat(Decoder(Buffer.from(value.replace(/ /g, ''), 'hex'), Number(port.value)), serie)); } }