SenseCAP-T1000-AB-upload-formater.js

// TTN uses JavaScript ECMAScript 5.1
// Corrected and Modified version of original SenseCAP formater.
// Formater can be used for tracker: SenseCAP T1000-A/B and perhaps others.
// Note: I kept this file "formated". But when pasting it into TTN upload formater field
//       it will be to big. Solution: first replace all spaces with tapulators and then remove it.
//       in VSCode: press Ctrl+Shift+P, "Convert Indentation to Tabs", Find/Replace "\t" with "" (regex)
// Author: Stephan Enderlein (2024)
// License: MIT
function decodeUplink(input) {
	var bytes = input.bytes;
	var fport = parseInt(input.fPort);
	var bytesString = bytes2HexString(bytes);
	var originMessage = bytesString.toLocaleUpperCase();
	var measurement = messageAnalyzed(originMessage);
	var elements = [];
	var i;
	var message;
	var decoded = {
		valid: true,
		err: 0,
		payload: bytesString,
		messages: [],
	};

	if (fport === 199 || fport === 192) {
		decoded.messages.push({ "fport": fport, "payload": bytesString });
		return { data: decoded };
	}
	if (measurement.length === 0) {
		decoded.valid = false;
		return { data: decoded };
	}

	// search errors, ignore invalid
	for (i = 0; i < measurement.length; i += 1) {
		message = measurement[i];
		if (message.length > 0 && message.errorCode) {
			decoded.err = message.errorCode;
			decoded.errMessage = message.error;
			return { data: decoded };
		}
		if (Number.isNaN(message.measurementValue)) {
			message.measurementValue = "error: NaN";
		}
		decoded.timestamp = message.timestamp;
		if (message.type == "Battery") { decoded.battery = message.measurementValue; }
		if (message.type == "Light") { decoded.light = message.measurementValue; }
		if (message.type == "Temperature") { decoded.temperature = message.measurementValue; }
		if (message.type == "Latitude") { decoded.latitude = message.measurementValue; }
		if (message.type == "Longitude") { decoded.longitude = message.measurementValue; }
		if (message.type == "Event Status") { decoded.eventStatus = message.measurementValue; }
		if (message.motionId !== undefined) { decoded.motionCount = message.motionId; }
		if (message.type == "Wi-Fi Scan") { decoded.access_points = message.measurementValue; }
	}

	decoded.messages = measurement;
	return { data: decoded };
}

function messageAnalyzed(messageValue) {
	var frames;
	var measurementResultArray = [];
	var i;
	var item;
	var dataId;
	var dataValue;
	var measurementArray = [];
	try {
		frames = unpack(messageValue);
		for (i = 0; i < frames.length; i += 1) {
			item = frames[i];
			dataId = item.dataId;
			dataValue = item.dataValue;
			measurementArray = deserialize(dataId, dataValue);
			// append content of measurementArray directly in result array (avoid nested arrays)
			measurementResultArray.push(...measurementArray);
		}
		return measurementResultArray;
	} catch (e) {
		return e.toString();
	}
}

function unpack(messageValue) {
	var frameArray = [];
	var remainMessage = messageValue;
	var dataId;
	var dataValue;
	var dataObj = {};
	var packageLen;

	while (remainMessage.length > 0) {
		dataId = remainMessage.substring(0, 2).toUpperCase();
		switch (dataId) {
			case "01":
				dataValue = remainMessage.substring(2, 94);
				remainMessage = remainMessage.substring(94);
				break;
			case "02":
				dataValue = remainMessage.substring(2, 32);
				remainMessage = remainMessage.substring(32);
				break;
			case "03":
				dataValue = remainMessage.substring(2, 64);
				remainMessage = remainMessage.substring(64);
				break;
			case "04":
				dataValue = remainMessage.substring(2, 20);
				remainMessage = remainMessage.substring(20);
				break;
			case "05":
				dataValue = remainMessage.substring(2, 10);
				remainMessage = remainMessage.substring(10);
				break;
			case "06":
				dataValue = remainMessage.substring(2, 44);
				remainMessage = remainMessage.substring(44);
				break;
			case "07":
				dataValue = remainMessage.substring(2, 84);
				remainMessage = remainMessage.substring(84);
				break;
			case "08":
				dataValue = remainMessage.substring(2, 70);
				remainMessage = remainMessage.substring(70);
				break;
			case "09":
				dataValue = remainMessage.substring(2, 36);
				remainMessage = remainMessage.substring(36);
				break;
			case "0A":
				dataValue = remainMessage.substring(2, 76);
				remainMessage = remainMessage.substring(76);
				break;
			case "0B":
				dataValue = remainMessage.substring(2, 62);
				remainMessage = remainMessage.substring(62);
				break;
			case "0C":
				break;
			case "0D":
				dataValue = remainMessage.substring(2, 10);
				remainMessage = remainMessage.substring(10);
				break;
			case "0E":
				packageLen = getInt(remainMessage.substring(8, 10)) * 2 + 10;
				dataValue = remainMessage.substring(2, 8) + remainMessage.substring(10, packageLen);
				remainMessage = remainMessage.substring(packageLen);
				break;
			case "0F":
				dataValue = remainMessage.substring(2, 34);
				remainMessage = remainMessage.substring(34);
				break;
			case "10":
				dataValue = remainMessage.substring(2, 26);
				remainMessage = remainMessage.substring(26);
				break;
			case "11":
				dataValue = remainMessage.substring(2, 28);
				remainMessage = remainMessage.substring(28);
				break;
			case "1A":
				dataValue = remainMessage.substring(2, 56);
				remainMessage = remainMessage.substring(56);
				break;
			case "1B":
				dataValue = remainMessage.substring(2, 96);
				remainMessage = remainMessage.substring(96);
				break;
			case "1C":
				dataValue = remainMessage.substring(2, 82);
				remainMessage = remainMessage.substring(82);
				break;
			case "1D":
				dataValue = remainMessage.substring(2, 40);
				remainMessage = remainMessage.substring(40);
				break;
			default:
				return frameArray;
		}

		if (dataValue && dataValue.length >= 2) {
			dataObj = {
				"dataId": dataId,
				"dataValue": dataValue
			};
			frameArray.push(dataObj);
		}
	}
	return frameArray;
}

function deserialize(dataId, dataValue) {
	var measurementArray = [];
	//var eventList = [];
	var measurement = {};
	var collectTime = 0;
	var groupId = 0;
	var shardFlag = {};
	var payload = "";
	var motionId = "";
	var interval;
	var workMode;
	var heartbeatInterval;
	var periodicInterval;
	var eventInterval;
	var errorCode;
	var error;

	switch (dataId) {
		case "01":
			measurementArray = getUpShortInfo(dataValue);
			Array.prototype.push.apply(measurementArray, getMotionSetting(dataValue.substring(30, 40)));
			Array.prototype.push.apply(measurementArray, getStaticSetting(dataValue.substring(40, 46)));
			Array.prototype.push.apply(measurementArray, getShockSetting(dataValue.substring(46, 52)));
			Array.prototype.push.apply(measurementArray, getTempSetting(dataValue.substring(52, 72)));
			Array.prototype.push.apply(measurementArray, getLightSetting(dataValue.substring(72, 92)));
			break;
		case "02":
			measurementArray = getUpShortInfo(dataValue);
			break;
		case "03":
			Array.prototype.push.apply(measurementArray, getMotionSetting(dataValue.substring(0, 10)));
			Array.prototype.push.apply(measurementArray, getStaticSetting(dataValue.substring(10, 16)));
			Array.prototype.push.apply(measurementArray, getShockSetting(dataValue.substring(16, 22)));
			Array.prototype.push.apply(measurementArray, getTempSetting(dataValue.substring(22, 42)));
			Array.prototype.push.apply(measurementArray, getLightSetting(dataValue.substring(42, 62)));
			break;
		case "04":
			interval = 0;
			workMode = getInt(dataValue.substring(0, 2));
			heartbeatInterval = getMinsByMin(dataValue.substring(4, 8));
			periodicInterval = getMinsByMin(dataValue.substring(8, 12));
			eventInterval = getMinsByMin(dataValue.substring(12, 16));
			switch (workMode) {
				case 0:
					interval = heartbeatInterval;
					break;
				case 1:
					interval = periodicInterval;
					break;
				case 2:
					interval = eventInterval;
					break;
			}
			measurementArray = [
				{ measurementId: "3940", type: "Work Mode", measurementValue: workMode },
				{ measurementId: "3942", type: "Heartbeat Interval", measurementValue: heartbeatInterval },
				{ measurementId: "3943", type: "Periodic Interval", measurementValue: periodicInterval },
				{ measurementId: "3944", type: "Event Interval", measurementValue: eventInterval },
				{ measurementId: "3941", type: "SOS Mode", measurementValue: getSOSMode(dataValue.substring(16, 18)) },
				{ measurementId: "3900", type: "Uplink Interval", measurementValue: interval }
			];
			break;
		case "05":
			measurementArray = [
				{ measurementId: "3000", type: "Battery", measurementValue: getBattery(dataValue.substring(0, 2)) },
				{ measurementId: "3940", type: "Work Mode", measurementValue: getWorkingMode(dataValue.substring(2, 4)) },
				{ measurementId: "3965", type: "Positioning Strategy", measurementValue: getPositioningStrategy(dataValue.substring(4, 6)) },
				{ measurementId: "3941", type: "SOS Mode", measurementValue: getSOSMode(dataValue.substring(6, 8)) }
			];
			break;
		case "06":
			collectTime = getUTCTimestamp(dataValue.substring(8, 16));
			motionId = getMotionId(dataValue.substring(6, 8));
			measurementArray = [
				{ measurementId: "4200", timestamp: collectTime, "motionId": motionId, type: "Event Status", measurementValue: getEventStatus(dataValue.substring(0, 6)) },
				{ measurementId: "4197", timestamp: collectTime, "motionId": motionId, type: "Longitude", measurementValue: parseFloat(getSensorValue(dataValue.substring(16, 24), 1000000)) },
				{ measurementId: "4198", timestamp: collectTime, "motionId": motionId, type: "Latitude", measurementValue: parseFloat(getSensorValue(dataValue.substring(24, 32), 1000000)) },
				{ measurementId: "4097", timestamp: collectTime, "motionId": motionId, type: "Temperature", measurementValue: getSensorValue(dataValue.substring(32, 36), 10) },
				{ measurementId: "4199", timestamp: collectTime, "motionId": motionId, type: "Light", measurementValue: getSensorValue(dataValue.substring(36, 40)) },
				{ measurementId: "3000", timestamp: collectTime, "motionId": motionId, type: "Battery", measurementValue: getBattery(dataValue.substring(40, 42)) }
			];
			break;
		case "07":
			//eventList = getEventStatus(dataValue.substring(0, 6));
			collectTime = getUTCTimestamp(dataValue.substring(8, 16));
			motionId = getMotionId(dataValue.substring(6, 8));
			measurementArray = [
				{ measurementId: "4200", timestamp: collectTime, "motionId": motionId, type: "Event Status", measurementValue: getEventStatus(dataValue.substring(0, 6)) },
				{ measurementId: "5001", timestamp: collectTime, "motionId": motionId, type: "Wi-Fi Scan", measurementValue: getMacAndRssiObj(dataValue.substring(16, 72)) },
				{ measurementId: "4097", timestamp: collectTime, "motionId": motionId, type: "Temperature", measurementValue: getSensorValue(dataValue.substring(72, 76), 10) },
				{ measurementId: "4199", timestamp: collectTime, "motionId": motionId, type: "Light", measurementValue: getSensorValue(dataValue.substring(76, 80)) },
				{ measurementId: "3000", timestamp: collectTime, "motionId": motionId, type: "Battery", measurementValue: getBattery(dataValue.substring(80, 82)) }
			];
			break;
		case "08":
			collectTime = getUTCTimestamp(dataValue.substring(8, 16));
			motionId = getMotionId(dataValue.substring(6, 8));
			measurementArray = [
				{ measurementId: "4200", timestamp: collectTime, "motionId": motionId, type: "Event Status", measurementValue: getEventStatus(dataValue.substring(0, 6)) },
				{ measurementId: "5002", timestamp: collectTime, "motionId": motionId, type: "BLE Scan", measurementValue: getMacAndRssiObj(dataValue.substring(16, 58)) },
				{ measurementId: "4097", timestamp: collectTime, "motionId": motionId, type: "Temperature", measurementValue: getSensorValue(dataValue.substring(58, 62), 10) },
				{ measurementId: "4199", timestamp: collectTime, "motionId": motionId, type: "Light", measurementValue: getSensorValue(dataValue.substring(62, 66)) },
				{ measurementId: "3000", timestamp: collectTime, "motionId": motionId, type: "Battery", measurementValue: getBattery(dataValue.substring(66, 68)) }
			];
			break;
		case "09":
			collectTime = getUTCTimestamp(dataValue.substring(8, 16));
			motionId = getMotionId(dataValue.substring(6, 8));
			measurementArray = [
				{ measurementId: "4200", timestamp: collectTime, "motionId": motionId, type: "Event Status", measurementValue: getEventStatus(dataValue.substring(0, 6)) },
				{ measurementId: "4197", timestamp: collectTime, "motionId": motionId, type: "Longitude", measurementValue: parseFloat(getSensorValue(dataValue.substring(16, 24), 1000000)) },
				{ measurementId: "4198", timestamp: collectTime, "motionId": motionId, type: "Latitude", measurementValue: parseFloat(getSensorValue(dataValue.substring(24, 32), 1000000)) },
				{ measurementId: "3000", timestamp: collectTime, "motionId": motionId, type: "Battery", measurementValue: getBattery(dataValue.substring(32, 34)) }
			];
			break;
		case "0A":
			collectTime = getUTCTimestamp(dataValue.substring(8, 16));
			motionId = getMotionId(dataValue.substring(6, 8));
			measurementArray = [
				{ measurementId: "4200", timestamp: collectTime, "motionId": motionId, type: "Event Status", measurementValue: getEventStatus(dataValue.substring(0, 6)) },
				{ measurementId: "5001", timestamp: collectTime, "motionId": motionId, type: "Wi-Fi Scan", measurementValue: getMacAndRssiObj(dataValue.substring(16, 72)) },
				{ measurementId: "3000", timestamp: collectTime, "motionId": motionId, type: "Battery", measurementValue: getBattery(dataValue.substring(72, 74)) }
			];
			break;
		case "0B":
			collectTime = getUTCTimestamp(dataValue.substring(8, 16));
			motionId = getMotionId(dataValue.substring(6, 8));
			measurementArray = [
				{ measurementId: "4200", timestamp: collectTime, "motionId": motionId, type: "Event Status", measurementValue: getEventStatus(dataValue.substring(0, 6)) },
				{ measurementId: "5002", timestamp: collectTime, "motionId": motionId, type: "BLE Scan", measurementValue: getMacAndRssiObj(dataValue.substring(16, 58)) },
				{ measurementId: "3000", timestamp: collectTime, "motionId": motionId, type: "Battery", measurementValue: getBattery(dataValue.substring(58, 60)) }
			];
			break;
		case "0D":
			errorCode = getInt(dataValue);
			error = "";
			switch (errorCode) {
				case 1:
					error = "FAILED TO OBTAIN THE UTC TIMESTAMP";
					break;
				case 2:
					error = "ALMANAC TOO OLD";
					break;
				case 3:
					error = "DOPPLER ERROR";
					break;
			}
			measurementArray.push({ "errorCode": errorCode, "error": error });
			break;
		case "0E":
			shardFlag = getShardFlag(dataValue.substring(0, 2));
			groupId = getInt(dataValue.substring(2, 6));
			payload = dataValue.substring(6);
			measurement = {
				measurementId: "6152",
				"groupId": groupId,
				index: shardFlag.index,
				count: shardFlag.count,
				type: "gnss-ng payload",
				measurementValue: payload
			};
			measurementArray.push(measurement);
			break;
		case "0F":
			collectTime = getUTCTimestamp(dataValue.substring(8, 16));
			shardFlag = getShardFlag(dataValue.substring(26, 28));
			groupId = getInt(dataValue.substring(28, 32));
			motionId = getMotionId(dataValue.substring(6, 8));
			measurementArray.push({
				measurementId: "4200",
				timestamp: collectTime,
				"motionId": motionId,
				"groupId": groupId,
				index: shardFlag.index,
				count: shardFlag.count,
				type: "Event Status",
				measurementValue: getEventStatus(dataValue.substring(0, 6))
			});
			measurementArray.push({
				measurementId: "4097",
				timestamp: collectTime,
				"motionId": motionId,
				"groupId": groupId,
				index: shardFlag.index,
				count: shardFlag.count,
				type: "Temperature",
				measurementValue: getSensorValue(dataValue.substring(16, 20), 10)
			});
			measurementArray.push({
				measurementId: "4199",
				timestamp: collectTime,
				"motionId": motionId,
				"groupId": groupId,
				index: shardFlag.index,
				count: shardFlag.count,
				type: "Light",
				measurementValue: getSensorValue(dataValue.substring(20, 24))
			});
			measurementArray.push({
				measurementId: "3000",
				timestamp: collectTime,
				"motionId": motionId,
				"groupId": groupId,
				index: shardFlag.index,
				count: shardFlag.count,
				type: "Battery",
				measurementValue: getBattery(dataValue.substring(24, 26))
			});
			break;
		case "10":
			collectTime = getUTCTimestamp(dataValue.substring(8, 16));
			shardFlag = getShardFlag(dataValue.substring(18, 20));
			groupId = getInt(dataValue.substring(20, 24));
			motionId = getMotionId(dataValue.substring(6, 8));
			measurementArray.push({
				measurementId: "4200",
				timestamp: collectTime,
				"motionId": motionId,
				"groupId": groupId,
				index: shardFlag.index,
				count: shardFlag.count,
				type: "Event Status",
				measurementValue: getEventStatus(dataValue.substring(0, 6))
			});
			measurementArray.push({
				measurementId: "3000",
				timestamp: collectTime,
				"motionId": motionId,
				"groupId": groupId,
				index: shardFlag.index,
				count: shardFlag.count,
				type: "Battery",
				measurementValue: getBattery(dataValue.substring(16, 18))
			});
			break;
		case "11":
			collectTime = getUTCTimestamp(dataValue.substring(8, 16));
			measurementArray.push({
				measurementId: "3576",
				timestamp: collectTime,
				type: "Positioning Status",
				measurementValue: getPositingStatus(dataValue.substring(0, 2))
			});
			measurementArray.push({
				timestamp: collectTime,
				measurementId: "4200",
				type: "Event Status",
				measurementValue: getEventStatus(dataValue.substring(2, 8))
			});
			if (!Number.isNaN(parseFloat(getSensorValue(dataValue.substring(16, 20), 10)))) {
				measurementArray.push({
					timestamp: collectTime,
					measurementId: "4097",
					type: "Temperature",
					measurementValue: getSensorValue(dataValue.substring(16, 20), 10)
				});
			}
			if (!Number.isNaN(parseFloat(getSensorValue(dataValue.substring(20, 24))))) {
				measurementArray.push({
					timestamp: collectTime,
					measurementId: "4199",
					type: "Light",
					measurementValue: getSensorValue(dataValue.substring(20, 24))
				});
			}
			if (!Number.isNaN(getBattery(dataValue.substring(36, 38)))) {
				measurementArray.push({
					timestamp: collectTime,
					measurementId: "3000",
					type: "Battery",
					measurementValue: getBattery(dataValue.substring(36, 38))
				});
			}
			break;
		case "1A":
			collectTime = getUTCTimestamp(dataValue.substring(8, 16));
			motionId = getMotionId(dataValue.substring(6, 8));
			measurementArray = [
				{ measurementId: "4200", timestamp: collectTime, "motionId": motionId, type: "Event Status", measurementValue: getEventStatus(dataValue.substring(0, 6)) },
				{ measurementId: "4197", timestamp: collectTime, "motionId": motionId, type: "Longitude", measurementValue: parseFloat(getSensorValue(dataValue.substring(16, 24), 1000000)) },
				{ measurementId: "4198", timestamp: collectTime, "motionId": motionId, type: "Latitude", measurementValue: parseFloat(getSensorValue(dataValue.substring(24, 32), 1000000)) },
				{ measurementId: "4097", timestamp: collectTime, "motionId": motionId, type: "Temperature", measurementValue: getSensorValue(dataValue.substring(32, 36), 10) },
				{ measurementId: "4199", timestamp: collectTime, "motionId": motionId, type: "Light", measurementValue: getSensorValue(dataValue.substring(36, 40)) },
				{ measurementId: "4210", timestamp: collectTime, "motionId": motionId, type: "AccelerometerX", measurementValue: getSensorValue(dataValue.substring(40, 44)) },
				{ measurementId: "4211", timestamp: collectTime, "motionId": motionId, type: "AccelerometerY", measurementValue: getSensorValue(dataValue.substring(44, 48)) },
				{ measurementId: "4212", timestamp: collectTime, "motionId": motionId, type: "AccelerometerZ", measurementValue: getSensorValue(dataValue.substring(48, 52)) },
				{ measurementId: "3000", timestamp: collectTime, "motionId": motionId, type: "Battery", measurementValue: getBattery(dataValue.substring(52, 54)) }
			];
			break;
		case "1B":
			collectTime = getUTCTimestamp(dataValue.substring(8, 16));
			motionId = getMotionId(dataValue.substring(6, 8));
			measurementArray = [
				{ measurementId: "4200", timestamp: collectTime, "motionId": motionId, type: "Event Status", measurementValue: getEventStatus(dataValue.substring(0, 6)) },
				{ measurementId: "5001", timestamp: collectTime, "motionId": motionId, type: "Wi-Fi Scan", measurementValue: getMacAndRssiObj(dataValue.substring(16, 72)) },
				{ measurementId: "4097", timestamp: collectTime, "motionId": motionId, type: "Temperature", measurementValue: getSensorValue(dataValue.substring(72, 76), 10) },
				{ measurementId: "4199", timestamp: collectTime, "motionId": motionId, type: "Light", measurementValue: getSensorValue(dataValue.substring(76, 80)) },
				{ measurementId: "4210", timestamp: collectTime, "motionId": motionId, type: "AccelerometerX", measurementValue: getSensorValue(dataValue.substring(80, 84)) },
				{ measurementId: "4211", timestamp: collectTime, "motionId": motionId, type: "AccelerometerY", measurementValue: getSensorValue(dataValue.substring(84, 88)) },
				{ measurementId: "4212", timestamp: collectTime, "motionId": motionId, type: "AccelerometerZ", measurementValue: getSensorValue(dataValue.substring(88, 92)) },
				{ measurementId: "3000", timestamp: collectTime, "motionId": motionId, type: "Battery", measurementValue: getBattery(dataValue.substring(92, 94)) }
			];
			break;
		case "1C":
			collectTime = getUTCTimestamp(dataValue.substring(8, 16));
			motionId = getMotionId(dataValue.substring(6, 8));
			measurementArray = [
				{ measurementId: "4200", timestamp: collectTime, "motionId": motionId, type: "Event Status", measurementValue: getEventStatus(dataValue.substring(0, 6)) },
				{ measurementId: "5002", timestamp: collectTime, "motionId": motionId, type: "BLE Scan", measurementValue: getMacAndRssiObj(dataValue.substring(16, 58)) },
				{ measurementId: "4097", timestamp: collectTime, "motionId": motionId, type: "Temperature", measurementValue: getSensorValue(dataValue.substring(58, 62), 10) },
				{ measurementId: "4199", timestamp: collectTime, "motionId": motionId, type: "Light", measurementValue: getSensorValue(dataValue.substring(62, 66)) },
				{ measurementId: "4210", timestamp: collectTime, "motionId": motionId, type: "AccelerometerX", measurementValue: getSensorValue(dataValue.substring(66, 70)) },
				{ measurementId: "4211", timestamp: collectTime, "motionId": motionId, type: "AccelerometerY", measurementValue: getSensorValue(dataValue.substring(70, 74)) },
				{ measurementId: "4212", timestamp: collectTime, "motionId": motionId, type: "AccelerometerZ", measurementValue: getSensorValue(dataValue.substring(74, 78)) },
				{ measurementId: "3000", timestamp: collectTime, "motionId": motionId, type: "Battery", measurementValue: getBattery(dataValue.substring(78, 80)) }
			];
			break;
		case "1D":
			collectTime = getUTCTimestamp(dataValue.substring(8, 16));
			measurementArray.push({
				measurementId: "3576",
				timestamp: collectTime,
				type: "Positioning Status",
				measurementValue: getPositingStatus(dataValue.substring(0, 2))
			});
			measurementArray.push({
				timestamp: collectTime,
				measurementId: "4200",
				type: "Event Status",
				measurementValue: getEventStatus(dataValue.substring(2, 8))
			});
			if (!Number.isNaN(parseFloat(getSensorValue(dataValue.substring(16, 20), 10)))) {
				measurementArray.push({
					timestamp: collectTime,
					measurementId: "4097",
					type: "Temperature",
					measurementValue: getSensorValue(dataValue.substring(16, 20), 10)
				});
			}
			if (!Number.isNaN(parseFloat(getSensorValue(dataValue.substring(20, 24))))) {
				measurementArray.push({
					timestamp: collectTime,
					measurementId: "4199",
					type: "Light",
					measurementValue: getSensorValue(dataValue.substring(20, 24))
				});
			}
			measurementArray.push({
				timestamp: collectTime,
				measurementId: "4210",
				type: "AccelerometerX",
				measurementValue: getSensorValue(dataValue.substring(24, 28))
			});
			measurementArray.push({
				timestamp: collectTime,
				measurementId: "4211",
				type: "AccelerometerY",
				measurementValue: getSensorValue(dataValue.substring(28, 32))
			});
			measurementArray.push({
				timestamp: collectTime,
				measurementId: "4212",
				type: "AccelerometerZ",
				measurementValue: getSensorValue(dataValue.substring(32, 36))
			});
			measurementArray.push({
				timestamp: collectTime,
				measurementId: "3000",
				type: "Battery",
				measurementValue: getBattery(dataValue.substring(36, 38))
			});
			break;
	}
	return measurementArray;
}


function getMotionId(str) {
	return getInt(str);
}

function getPositingStatus(str) {
	var status = getInt(str);
	switch (status) {
		case 0:
			return { id: status, statusName: "Positioning successful." };
		case 1:
			return { id: status, statusName: "The GNSS scan timed out and failed to obtain the location." };
		case 2:
			return { id: status, statusName: "The Wi-Fi scan timed out and failed to obtain the location." };
		case 3:
			return { id: status, statusName: "The Wi-Fi + GNSS scan timed out and failed to obtain the location." };
		case 4:
			return { id: status, statusName: "The GNSS + Wi-Fi scan timed out and failed to obtain the location." };
		case 5:
			return { id: status, statusName: "The Bluetooth scan timed out and failed to obtain the location." };
		case 6:
			return { id: status, statusName: "The Bluetooth + Wi-Fi scan timed out and failed to obtain the location." };
		case 7:
			return { id: status, statusName: "The Bluetooth + GNSS scan timed out and failed to obtain the location." };
		case 8:
			return { id: status, statusName: "The Bluetooth + Wi-Fi + GNSS scan timed out and failed to obtain the location." };
		case 9:
			return { id: status, statusName: "Location Server failed to parse the GNSS location." };
		case 10:
			return { id: status, statusName: "Location Server failed to parse the Wi-Fi location." };
		case 11:
			return { id: status, statusName: "Location Server failed to parse the Bluetooth location." };
		case 12:
			return { id: status, statusName: "Failed to parse the GNSS location due to the poor accuracy." };
		case 13:
			return { id: status, statusName: "Time synchronization failed." };
		case 14:
			return { id: status, statusName: "Failed to obtain location due to the old Almanac." };
	}
	return getInt(str);
}

function getUpShortInfo(messageValue) {
	return [
		{
			measurementId: "3000", type: "Battery", measurementValue: getBattery(messageValue.substring(0, 2))
		}, {
			measurementId: "3502", type: "Firmware Version", measurementValue: getSoftVersion(messageValue.substring(2, 6))
		}, {
			measurementId: "3001", type: "Hardware Version", measurementValue: getHardVersion(messageValue.substring(6, 10))
		}, {
			measurementId: "3940", type: "Work Mode", measurementValue: getWorkingMode(messageValue.substring(10, 12))
		}, {
			measurementId: "3965", type: "Positioning Strategy", measurementValue: getPositioningStrategy(messageValue.substring(12, 14))
		}, {
			measurementId: "3942", type: "Heartbeat Interval", measurementValue: getMinsByMin(messageValue.substring(14, 18))
		}, {
			measurementId: "3943", type: "Periodic Interval", measurementValue: getMinsByMin(messageValue.substring(18, 22))
		}, {
			measurementId: "3944", type: "Event Interval", measurementValue: getMinsByMin(messageValue.substring(22, 26))
		}, {
			measurementId: "3945", type: "Sensor Enable", measurementValue: getInt(messageValue.substring(26, 28))
		}, {
			measurementId: "3941", type: "SOS Mode", measurementValue: getSOSMode(messageValue.substring(28, 30))
		}
	];
}

function getMotionSetting(str) {
	return [
		{ measurementId: "3946", type: "Motion Enable", measurementValue: getInt(str.substring(0, 2)) },
		{ measurementId: "3947", type: "Any Motion Threshold", measurementValue: getSensorValue(str.substring(2, 6), 1) },
		{ measurementId: "3948", type: "Motion Start Interval", measurementValue: getMinsByMin(str.substring(6, 10)) }
	];
}

function getStaticSetting(str) {
	return [
		{ measurementId: "3949", type: "Static Enable", measurementValue: getInt(str.substring(0, 2)) },
		{ measurementId: "3950", type: "Device Static Timeout", measurementValue: getMinsByMin(str.substring(2, 6)) }
	];
}

function getShockSetting(str) {
	return [
		{ measurementId: "3951", type: "Shock Enable", measurementValue: getInt(str.substring(0, 2)) },
		{ measurementId: "3952", type: "Shock Threshold", measurementValue: getInt(str.substring(2, 6)) }
	];
}

function getTempSetting(str) {
	return [
		{ measurementId: "3953", type: "Temp Enable", measurementValue: getInt(str.substring(0, 2)) },
		{ measurementId: "3954", type: "Event Temp Interval", measurementValue: getMinsByMin(str.substring(2, 6)) },
		{ measurementId: "3955", type: "Event Temp Sample Interval", measurementValue: getSecondsByInt(str.substring(6, 10)) },
		{ measurementId: "3956", type: "Temp ThMax", measurementValue: getSensorValue(str.substring(10, 14), 10) },
		{ measurementId: "3957", type: "Temp ThMin", measurementValue: getSensorValue(str.substring(14, 18), 10) },
		{ measurementId: "3958", type: "Temp Warning Type", measurementValue: getInt(str.substring(18, 20)) }
	];
}

function getLightSetting(str) {
	return [
		{ measurementId: "3959", type: "Light Enable", measurementValue: getInt(str.substring(0, 2)) },
		{ measurementId: "3960", type: "Event Light Interval", measurementValue: getMinsByMin(str.substring(2, 6)) },
		{ measurementId: "3961", type: "Event Light Sample Interval", measurementValue: getSecondsByInt(str.substring(6, 10)) },
		{ measurementId: "3962", type: "Light ThMax", measurementValue: getSensorValue(str.substring(10, 14), 10) },
		{ measurementId: "3963", type: "Light ThMin", measurementValue: getSensorValue(str.substring(14, 18), 10) },
		{ measurementId: "3964", type: "Light Warning Type", measurementValue: getInt(str.substring(18, 20)) }
	];
}

function getShardFlag(str) {
	var bitStr = getByteArray(str);
	return {
		count: parseInt(bitStr.substring(0, 4), 2),
		index: parseInt(bitStr.substring(4), 2)
	};
}

function getBattery(batteryStr) {
	return loraWANV2DataFormat(batteryStr);
}
function getSoftVersion(softVersion) {
	return `${loraWANV2DataFormat(softVersion.substring(0, 2))}.${loraWANV2DataFormat(softVersion.substring(2, 4))}`;
}
function getHardVersion(hardVersion) {
	return `${loraWANV2DataFormat(hardVersion.substring(0, 2))}.${loraWANV2DataFormat(hardVersion.substring(2, 4))}`;
}

function getSecondsByInt(str) {
	return getInt(str);
}

function getMinsByMin(str) {
	return getInt(str);
}

function getSensorValue(str, dig) {
	if (str === "8000") {
		return null;
	} else {
		return loraWANV2DataFormat(str, dig);
	}
}

function bytes2HexString(arrBytes) {
	var str = "";
	var i;
	var tmp;
	var num;
	for (i = 0; i < arrBytes.length; i += 1) {
		num = arrBytes[i];
		if (num < 0) {
			tmp = (255 + num + 1);
			tmp = tmp.toString(16);
		} else {
			tmp = num.toString(16);
		}
		if (tmp.length === 1) {
			tmp = "0" + tmp;
		}
		str += tmp;
	}
	return str;
}
function loraWANV2DataFormat(str, divisor = 1) {
	var strReverse = bigEndianTransform(str);
	var str2 = toBinary(strReverse);
	var arr = [];
	var reverseArr = [];
	if (str2.substring(0, 1) === "1") {
		arr = str2.split("");
		reverseArr = arr.map(function (item) {
			if (parseInt(item) === 1) {
				return 0;
			} else {
				return 1;
			}
		});
		str2 = parseInt(reverseArr.join(""), 2) + 1;
		return parseFloat("-" + str2 / divisor);
	}
	return parseInt(str2, 2) / divisor;
}

function bigEndianTransform(data) {
	var dataArray = [];
	var i;
	for (i = 0; i < data.length; i += 2) {
		dataArray.push(data.substring(i, i + 2));
	}
	return dataArray;
}

function toBinary(arr) {
	var i;
	var binaryData = arr.map(function (item) {
		var data = parseInt(item, 16)
			.toString(2);
		var dataLength = data.length;
		if (data.length !== 8) {
			for (i = 0; i < 8 - dataLength; i += 1) {
				data = `0` + data;
			}
		}
		return data;
	});
	return binaryData.toString().replace(/,/g, "");
}

function getSOSMode(str) {
	return loraWANV2DataFormat(str);
}

function getMacAndRssiObj(pair) {
	var pairs = [];
	var i;
	var bssid;
	var rssi;
	if (pair.length % 14 === 0) {
		for (i = 0; i < pair.length; i += 14) {
			bssid = getMacAddress(pair.substring(i, i + 12));
			if (bssid) {
				rssi = getInt8RSSI(pair.substring(i + 12, i + 14));
				pairs.push({ "bssid": bssid, "rssi": rssi });
			}
		}
	}
	return pairs;
}

function getMacAddress(str) {
	var macArr = [];
	var i;
	var mac = "";
	if (str.toLowerCase() === "ffffffffffff") {
		return null;
	}
	for (i = 1; i < str.length; i += 1) {
		if (i % 2 === 1) {
			macArr.push(str.substring(i - 1, i + 1));
		}
	}
	for (i = 0; i < macArr.length; i += 1) {
		mac = mac + macArr[i];
		if (i < macArr.length - 1) {
			mac = mac + ":";
		}
	}
	return mac;
}

function getInt8RSSI(str) {
	return loraWANV2DataFormat(str);
}

function getInt(str) {
	return parseInt(str, 16);
}

function getEventStatus(str) {
	// return getInt(str)
	var bitStr = getByteArray(str);
	var bitArr = [];
	var i;
	var event = [];
	for (i = 0; i < bitStr.length; i += 1) {
		bitArr[i] = bitStr.substring(i, i + 1);
	}
	bitArr = bitArr.reverse();
	for (i = 0; i < bitArr.length; i += 1) {
		if (bitArr[i] === "1") {
			switch (i) {
				case 0:
					event.push({ id: 1, eventName: "Start moving event." });
					break;
				case 1:
					event.push({ id: 2, eventName: "End movement event." });
					break;
				case 2:
					event.push({ id: 3, eventName: "Motionless event." });
					break;
				case 3:
					event.push({ id: 4, eventName: "Shock event." });
					break;
				case 4:
					event.push({ id: 5, eventName: "Temperature event." });
					break;
				case 5:
					event.push({ id: 6, eventName: "Light event." });
					break;
				case 6:
					event.push({ id: 7, eventName: "SOS event." });
					break;
				case 7:
					event.push({ id: 8, eventName: "Press once event." });
					break;
			}
		}
	}
	return event;
}

function getByteArray(str) {
	var bytes = [];
	var i;
	for (i = 0; i < str.length; i += 2) {
		bytes.push(str.substring(i, i + 2));
	}
	return toBinary(bytes);
}

function getWorkingMode(workingMode) {
	return getInt(workingMode);
}

function getPositioningStrategy(strategy) {
	return getInt(strategy);
}

function getUTCTimestamp(str) {
	return parseInt(loraWANV2PositiveDataFormat(str)) * 1000;
}

function loraWANV2PositiveDataFormat(str, divisor = 1) {
	var strReverse = bigEndianTransform(str);
	var str2 = toBinary(strReverse);
	return parseInt(str2, 2) / divisor;
}