概述

本文主要介绍如何将星纵物联LoRaWAN^®网关和终端节点连接到LinkWAN平台。目前平台只支持CN470频段，如下以星纵物联UG65网关和EM300传感器（LinkWAN版本）为例。

准备

星纵物联LoRaWAN^®网关
LoRaWAN^®终端节点（LinkWAN版）

步骤

1. 网关配置

1.1 获取密钥文件

用户提供网关序列号给设备厂商，厂商使用网关密钥管理工具生成配置文件；
用户获取配置压缩文件：（该文件包含了GwEUI和PIN Code两个参数，该参数在平台添加网关时需要使用）。

1.2 网关启用LinkWAN

进入网关配置页面“Packet Forwarder>常规”，根据下图，配置LinkWAN连接，需要在“导入配置文件”位置导入上一步生成的配置文件。

2. LinkWAN平台配置

登录LinkWAN物联网络管理平台：https://signin.aliyun.com。（可自助申请登录账号）

登录控制台，选择“物联网络管理平台>网络管理>网关管理>添加网关”。

输入配置文件中的GwEUI和PIN Code参数及对应信息，如下图所示。

“物联网络管理平台>网络管理>网关管理”，查看网关状态为在线。

点击查看，可以看到该网关的上下行数据，以及无效数据。（当无法收到节点数据时，可以查看无效数据。一般节点的JoinEUI或者DevEUI不合法等错误会打印在无效数据中。）

LinkWAN相关程序说明如下：

3. 传感器连接LinkWAN

3.1 创建凭证和密钥

进入“网络管理>入网开通>添加专用凭证”授权给自己。

进入“密钥管理>申请密钥>申请购买密钥”。注意：一个密钥配置文件1元。

3.2 新建产品

切换到物联网平台，先创建一个产品，如果没有凭证需要先创建凭证，并授权（选择授权给自己）。

3.3 添加设备

进入“设备管理>设备>添加设备”，输入节点的DevEUI和PIN Code，这两个参数在平台成功购买密钥后，可以从下载的密钥文件EXCEL表格中获取。

查看设备启用状态，刚添加完设备为未激活状态，设备成功上线后变为在线。

3.4 创建模型

进入物联网平台“设备管理>产品>产品详情”，选择对应产品，为设备创建物理模型。

添加自定义功能。

注意：标识符和数据类型应该遵循Decoder内的定义进行填写，否则会解析不成功。

A、EM300设备自定义功能参考如下：

B、UC1152设备自定义功能参考如下：

3.5 发布上线

3.6 设置数据解析

选择数据解析，将数据解析代码拷贝进去，具体代码见4.7（EM300）或4.8（UC1152）。

到设备物理模型下，可以查看设备的上报数据。

3.7 EM300数据解析代码如下

/**

* 将设备自定义topic数据转换为json格式数据, 设备上报数据到物联网平台时调用

* 入参：topic string 设备上报消息的topic

* 入参：rawData byte[]数组不能为空

* 出参：jsonObj JSON对象不能为空

*/

function array(length) {

return new Array(length).fill(null);

}

function fixFloat(float, fractionDigits) {

fractionDigits = fractionDigits || 1;

var value = typeof float === "string" ? parseFloat(float) : float;

return parseFloat(value.toFixed(fractionDigits));

}

function readUInt8(bytes) {

return (bytes & 0xFF);

}

function readInt8(bytes) {

var ref = readUInt8(bytes);

return (ref > 0x7F) ? ref - 0x100 : ref;

}

function readUInt16LE(bytes) {

var value = (bytes[1] << 8) + bytes[0];

return (value & 0xFFFF);

}

function readInt16LE(bytes) {

var ref = readUInt16LE(bytes);

return (ref > 0x7FFF) ? ref - 0x10000 : ref;

}

function readUInt32LE(bytes) {

var value = (bytes[3] << 24) + (bytes[2] << 16) + (bytes[1] << 8) + bytes[0];

return (value & 0xFFFFFFFF);

}

function readInt32LE(bytes) {

var ref = readUInt32LE(bytes);

return (ref > 0x7FFFFFFF) ? ref - 0x100000000 : ref;

}

function readFloatLE(bytes) {

var bits = bytes[3] << 24 | bytes[2] << 16 | bytes[1] << 8 | bytes[0];

var sign = (bits >>> 31 === 0) ? 1.0 : -1.0;

var e = bits >>> 23 & 0xff;

var m = (e === 0) ? (bits & 0x7fffff) << 1 : (bits & 0x7fffff) | 0x800000;

var f = sign * m * Math.pow(2, e - 150);

return f;

}

function BufferReader(buffer) {

this.buffer = buffer;

this.offset = 0;

}

BufferReader.prototype.getBuffer = function () {

return this.buffer;

}

BufferReader.prototype.byteAt = function (index) {

return this.buffer[index];

}

BufferReader.prototype.firstByte = function () {

return this.buffer[0];

}

BufferReader.prototype.lastByte = function () {

return this.buffer[this.buffer.length - 1];

}

BufferReader.prototype.hasNextByte = function () {

return this.buffer.length > this.offset;

}

BufferReader.prototype.moveOffset = function (plus) {

this.offset += plus;

}

BufferReader.prototype.setOffset = function (offset) {

this.offset = offset;

}

BufferReader.prototype.getOffset = function () {

return this.offset;

}

BufferReader.prototype.readBit = function (bits) {

var result = [];

var binary = this.readUInt8();

for (var idx = 0; idx < bits; idx++) {

result[idx] = (binary >> idx) & 1;

}

return result;

}

BufferReader.prototype.readUInt8 = function () {

var result = readUInt8(this.buffer.slice(this.offset, this.offset + 1));

this.offset += 1;

return result;

}

BufferReader.prototype.readInt16LE = function () {

var result = readInt16LE(this.buffer.slice(this.offset, this.offset + 2));

this.offset += 2;

return result;

}

BufferReader.prototype.readUInt16LE = function () {

var result = readUInt16LE(this.buffer.slice(this.offset, this.offset + 2));

this.offset += 2;

return result;

}

BufferReader.prototype.readInt32LE = function () {

var result = readInt32LE(this.buffer.slice(this.offset, this.offset + 4));

this.offset += 4;

return result;

}

BufferReader.prototype.readUInt32LE = function () {

var result = readUInt32LE(this.buffer.slice(this.offset, this.offset + 4));

this.offset += 4;

return result;

}

BufferReader.prototype.readFloatLE = function () {

var result = readFloatLE(this.buffer.slice(this.offset, this.offset + 4));

this.offset += 4;

return result;

}

BufferReader.prototype.readString = function (size) {

var result = this.buffer.slice(this.offset, this.offset + size);

this.offset += size;

return result.toString().replace(/\0/g, "");

}

BufferReader.prototype.readHex = function (length) {

var hex = this.buffer.slice(this.offset, this.offset + length).toString(16);

this.offset += length;

return hex;

}

BufferReader.prototype.readBuffer = function (length) {

var buffer = this.buffer.slice(this.offset, this.offset + length);

this.offset += length;

return buffer;

}

var DATA_TYPE = {

Int8: "Int8",

UInt8: "UInt8",

Int16: "Int16LE",

UInt16: "UInt16LE",

Int32LE: "Int32LE",

UInt32LE: "UInt32LE",

};

var IPSO_PARSER = {

0: defCommonChannelParser("digitalInput", DATA_TYPE.UInt8),

1: defCommonChannelParser("digitalOutput", DATA_TYPE.UInt8),

3: defCommonChannelParser("analogOutput", DATA_TYPE.Int16, undefined, function (value) { return fixFloat(value * 0.01, 2) }),

101: defCommonChannelParser("illumianceSensor", DATA_TYPE.UInt16, "lux"),

102: defCommonChannelParser("presenceSensor", DATA_TYPE.UInt8),

103: defCommonChannelParser("temperatureSensor", DATA_TYPE.Int16, "¡ãC", function (value) { return fixFloat(value * 0.1) }),

104: defCommonChannelParser("humiditySensor", DATA_TYPE.UInt8, "%", function (value) { return fixFloat(value * 0.5) }),

106: defCommonChannelParser("actuation", DATA_TYPE.UInt16, ""),

115: defCommonChannelParser("barometerPressure", DATA_TYPE.UInt16, "kPa", function (value) { return fixFloat(value * 0.1) }),

116: defCommonChannelParser("voltage", DATA_TYPE.UInt16, "V", function (value) { return fixFloat(value * 0.01, 2) }),

117: defCommonChannelParser("current", DATA_TYPE.UInt8, "%"),

119: defCommonChannelParser("depth", DATA_TYPE.UInt16, "cm", function (value) { return value }),

123: defCommonChannelParser("pressure", DATA_TYPE.UInt16, "", function (value) { return fixFloat(value * 0.1) }),

124: defCommonChannelParser("loudness", DATA_TYPE.UInt16, "dB", function (value) { return fixFloat(value * 0.1) }),

125: defCommonChannelParser("concentration", DATA_TYPE.UInt16, ""),

128: defCommonChannelParser("power", DATA_TYPE.UInt16, "W", function (value) { return fixFloat(value * 0.01, 2) }),

130: defCommonChannelParser("distance", DATA_TYPE.UInt16, "m", function (value) { return fixFloat(value / 1000, 3) }),

146: defCommonChannelParser("par", DATA_TYPE.UInt16, "¦Ìmol¡¤m?2¡¤s?1", function (value) { return fixFloat(value * 0.1) }),

200: defCommonChannelParser("counter", DATA_TYPE.UInt32LE),

};

// analog input

IPSO_PARSER[2] = function (channel) {

return function (reader, data) {

data[channel] = {

channel: channel,

type: "analogInput",

value: {

ccy: fixFloat(reader.readInt16LE() * 0.01, 2),

min: fixFloat(reader.readInt16LE() * 0.01, 2),

max: fixFloat(reader.readInt16LE() * 0.01, 2),

avg: fixFloat(reader.readInt16LE() * 0.01, 2),

},

};

}

};

var URSA_PARSER = {

1: defConfigDataParser("version", DATA_TYPE.UInt8, function (value) { return value.toString() }),

2: defConfigDataParser("interval", DATA_TYPE.UInt16),

3: defConfigDataParser("period", DATA_TYPE.UInt16),

4: defConfigDataParser("response", DATA_TYPE.UInt8),

5: parseLoRaChanMask,

6: skip(9, "alarmConfig"),

7: defConfigDataParser("debugLevel", DATA_TYPE.UInt8),

8: defSNParser(6),

9: parseVersion("hardware"),

10: parseVersion("firmware"),

11: defConfigDataParser("powerOn", DATA_TYPE.UInt8, function (value) { return value > 0 }),

12: defConfigDataParser("powerOff", DATA_TYPE.UInt8, function (value) { return value > 0 }),

13: parseAlarm,

14: parseChannels,

15: defConfigDataParser("class", DATA_TYPE.UInt8),

16: defConfigDataParser("reboot", DATA_TYPE.UInt8),

17: defConfigDataParser("timestamp", DATA_TYPE.UInt16),

18: parseText,

19: defConfigDataParser("intelligenceReport", DATA_TYPE.UInt8),

20: parseConversion,

21: parseCollectFailedChannelIds,

22: defSNParser(8),

};

function convertBufferToObject(buffer) {

var reader = new BufferReader(buffer);

var data = { config: {} };

while (reader.hasNextByte()) {

var channel = reader.readUInt8();

var type = reader.readUInt8();

var parser = getReadParser(channel, type);

if (parser) {

parser.parse(reader, data);

}

}

return data;

}

function getReadParser(channel, type) {

if (channel === 255) {

return { parse: URSA_PARSER[type] };

} else {

return { parse: IPSO_PARSER[type](channel) };

}

}

function defCommonChannelParser(type, dataType, unit, converter) {

return function (channel) {

return function (reader, data) {

var value = reader["read" + dataType]();

data[channel] = {

channel: channel,

type: type,

unit: unit,

value: (converter || function (value) { return value })(value),

};

}

};

}

function defConfigDataParser(property, dataType, converter) {

return function (reader, data) {

var value = reader["read" + dataType]();

if (!data.config) {

data.config = {};

}

data.config[property] = (converter || function (value) { return value })(value);

};

}

function skip(length, property) {

return function (reader, data) {

reader.moveOffset(length);

};

}

function defSNParser(length) {

return function (reader, data) {

data.config.sn = reader.readHex(length);

};

}

function parseLoRaChanMask(reader, data) {

var id = reader.readUInt8();

var value = reader.readUInt16LE();

data.config.loRaChanMask = { id: id, value: value };

}

function parseText(reader, data) {

var length = reader.readUInt8();

data.config.text = reader.readString(length);

}

function parseAlarm(reader, data) {

var MODE = ["DISABLE", "BELOW", "ABOVE", "WITHIN", "BELOW_OR_ABOVE"];

var idAndMode = reader.readUInt8();

var id = (idAndMode & 56) >>> 3; // & 0x00111000 >> 3

var mode = MODE[idAndMode & 7]; // & 0x00000111

var min = reader.readInt16LE() / 10;

var max = reader.readInt16LE() / 10;

var current = reader.readInt16LE() / 10;

var lessThan = min;

var greaterThan = max;

if (mode === "WITHIN") {

lessThan = max;

greaterThan = min;

} else if (mode === "BELOW_OR_ABOVE") {

mode = current < lessThan ? "BELOW" : "ABOVE";

}

data.config.alarm = { id: id, mode: mode, greaterThan: greaterThan, lessThan: lessThan, current: current };

}

function parseConversion(reader, data) {

var value = reader.readUInt8();

var index = (value & 240) >>> 4; // & 11110000 >> 4

var type = (value & 15) === 0 ? "mA" : "V"; // & 00001111

if (!data.config.conversion) {

data.config.conversion = [];

}

data.config.conversion.push({ index: index, type: type });

}

function parseVersion(property) {

return function (reader, data) {

var mainVer = reader.readUInt8();

var subVer = reader.readUInt8();

var realMainVer = mainVer % 16 + Math.floor(mainVer / 16) * 10;

var realSubVer = subVer % 16 === 0 && property === "hardware"

? Math.floor(subVer / 16)

: subVer % 16 + Math.floor(subVer / 16) * 10;

if (property === "hardware") {

data.config.hardware = "v" + realMainVer + "." + realSubVer;

} else if (property === "firmware") {

data.config.firmware = "v" + realMainVer + "." + realSubVer;

}

};

}

var CHANNEL_TYPE = ["REG_COIL", "REG_DISCRETE", "REG_INPUT", "REG_HOLD_INT16", "REG_HOLD_INT32",

"REG_HOLD_FLOAT", "REG_INPUT_INT32", "REG_INPUT_FLOAT",

"REG_INPUT_INT32_AB", "REG_INPUT_INT32_CD", "REG_HOLD_INT32_AB", "REG_HOLD_INT32_CD"];

function parseChannels(reader, data) {

var channelId = reader.readUInt8();

var ptype = reader.readUInt8();

var dataType = CHANNEL_TYPE[ptype & 7];

var dataLength = ptype >> 3;

var offset = reader.getOffset();

var raw = "";

var value = 0;

switch (dataType) {

case "REG_COIL":

case "REG_DISCRETE":

value = reader.readUInt8();

reader.setOffset(offset);

raw = reader.readHex(1);

break;

case "REG_INPUT":

case "REG_HOLD_INT16":

case "REG_INPUT_INT32_AB":

case "REG_INPUT_INT32_CD":

case "REG_HOLD_INT32_AB":

case "REG_HOLD_INT32_CD":

value = reader.readUInt16LE();

reader.setOffset(offset);

raw = reader.readHex(2);

break;

case "REG_HOLD_INT32":

case "REG_INPUT_INT32":

value = reader.readUInt32LE();

reader.setOffset(offset);

raw = reader.readHex(4);

break;

case "REG_HOLD_FLOAT":

case "REG_INPUT_FLOAT":

value = fixFloat(reader.readFloatLE(), 4);

reader.setOffset(offset);

raw = reader.readHex(4);

break;

}

if (!data.config.channelData) {

data.config.channelData = array(8);

}

data.config.channelData[channelId] = {

channelId: channelId,

dataType: dataType,

dataLength: dataLength,

value: value,

raw: raw,

};

}

function writeUInt8(bytes, value, index) {

bytes[index] = value;

}

function writeUInt16LE(bytes, value, index) {

var low = value & 0xFF;

var high = (value & 0xFF00) >> 8;

bytes[index] = low;

bytes[index + 1] = high;

}

function safeValue(value, defaultValue) {

if (value === null || value === undefined) {

return defaultValue;

}

value = Number(value);

if (value === NaN) {

return defaultValue;

}

return value;

}

function writeAlarm(alarmConfig) {

var MODE = { DISABLE: 0, BELOW: 1, ABOVE: 2, WITHIN: 3, BELOW_OR_ABOVE: 4 };

const bytes = new Uint8Array(11);

writeUInt8(bytes, 255, 0);

writeUInt8(bytes, 6, 1);

var idAndMode = ((alarmConfig.id || 0) << 3) + (MODE[alarmConfig.mode || "DISABLE"]);

writeUInt8(bytes, idAndMode, 2);

writeUInt8(bytes)

var upper = safeValue(alarmConfig.upper, 9999);

var lower = safeValue(alarmConfig.lower, 9999);

if ((alarmConfig.mode === "BELOW_OR_ABOVE" || alarmConfig.mode === "WITHIN") && upper > lower) {

// min和max都有值时min一定小于max

[upper, lower] = [lower, upper];

}

writeUInt16LE(bytes, upper, 3); // min

writeUInt16LE(bytes, lower, 5); // max

writeUInt16LE(bytes, 0, 7);

writeUInt16LE(bytes, 0, 9);

return bytes;

}

function parseCollectFailedChannelIds(reader, data) {

var ids = data.config.collectFailedChannelIds || [];

ids.push(reader.readUInt8());

data.config.collectFailedChannelIds = ids;

}

function Decoder(bytes, port) {

return convertBufferToObject(bytes);

}

function bufferToBytes(buffer) {

var bytes = [];

buffer.forEach(function (v) { bytes.push(v) });

return bytes;

}

function rawDataToProtocol(bytes) {

var data = convertBufferToObject(new Uint8Array(bytes));

var result = {};

// {"method":"thing.event.property.post", "id":"12345", "params":{"Temperature":1,"Humidity":2}, "version":"1.1"}

result.method = "thing.event.property.post";

result.version = "1.1";

result.id = "1";

result.params = {};

if (data[3]) {

result.params.temperature = data[3].value;

}

if (data[4]) {

result.params.humiditySensor = data[4].value;

}

if (data[6]) {

result.params.digitalInput = data[6].value;

}

if (data[5]) {

result.params.digitalInput1 = data[5].value;

}

if (data[1]) {

result.params.BatteryLevel = data[1].value;

}

return result;

}

function protocolToRawData(json) {

// {

// "method": "thing.service.SetTempHumiThreshold",

// "id": "12345",

// "version": "1.1",

// "params": {

// "MaxTemp": 50,

// "MinTemp": 8,

// "MaxHumi": 90,

// "MinHumi": 10

// }

// }

var header = [0x5D, 0x01, 0x00];

var params = json.params;

var lower = params.maxtemp;

var upper = params.mintemp;

var mode;

var isUpperExists = !!upper || upper === 0;

var isLowerExists = !!lower || lower === 0;

if (isUpperExists && !isLowerExists) {

mode = "BELOW";

} else if (!isUpperExists && isLowerExists) {

mode = "ABOVE";

} else if (!isUpperExists && !isLowerExists) {

return new Uint8Array([0x5d, 0x01, 0x00, 0xff, 0x06, 0x11, 0x14, 0x00, 0x32, 0x00, 0x3c, 0x00, 0x00, 0x00]);

}else if (lower <= upper) {

mode = "WITHIN";

} else if (lower > upper) {

mode = "BELOW_OR_ABOVE";

}

var payload = writeAlarm({id: 1, mode, upper, lower});

var arr = [];

payload.forEach(function (v, i) {

arr[i] = v;

})

return new Uint8Array(header.concat(arr));

}

function transformPayload() {

}

3.8 UC1152数据解析代码如下

/**

* 将设备自定义topic数据转换为json格式数据, 设备上报数据到物联网平台时调用

* 入参：topic string 设备上报消息的topic

* 入参：rawData byte[]数组不能为空

* 出参：jsonObj JSON对象不能为空

*/

function transformPayload(topic, rawData) {

var data = Decoder(rawData, 85);

var jsonObj = {};

jsonObj.method=topic;

jsonObj.version="1.0";

jsonObj.id="1";

jsonObj.params=data;

return jsonObj;

}

/**

* 将设备的自定义格式数据转换为Alink协议的数据，设备上报数据到物联网平台时调用

* 入参：rawData byte[]数组不能为空

* 出参：jsonObj Alink JSON对象不能为空

*/

function rawDataToProtocol(rawData) {

var data = Decoder(rawData, 85);

var jsonObj = {};

jsonObj.method="thing.event.property.post";

jsonObj.version="1.0";

jsonObj.id="1";

jsonObj.params=data;

return jsonObj;

}

/**

* 将Alink协议的数据转换为设备能识别的格式数据，物联网平台给设备下发数据时调用

* 入参：jsonObj Alink JSON对象不能为空

* 出参：rawData byte[]数组不能为空

*

*/

function protocolToRawData(jsonObj) {

var rawdata = [];

return rawdata;

}

function Decoder(bytes, port) {

var decoded = {};

for (i = 0; i < bytes.length;) {

var channel_id = bytes[i++];

var channel_type = bytes[i++];

// Digital Input 1

if (channel_id === 0x01 && channel_type !== 0xc8) {

decoded.din1 = bytes[i] === 0 ? "off" : "on";

i += 1;

}

// Digital Input 2

else if (channel_id === 0x02 && channel_type !== 0xc8) {

decoded.din2 = bytes[i] === 0 ? "off" : "on";

i += 1;

}

// Pulse Counter 1

else if (channel_id === 0x01 && channel_type === 0xc8) {

decoded.counter1 = readUInt32LE(bytes.slice(i, i + 4));

i += 4;

}

// Pulse Counter 1

else if (channel_id === 0x02 && channel_type === 0xc8) {

decoded.counter2 = readUInt32LE(bytes.slice(i, i + 4));

i += 4;

}

// Digital Output 1

else if (channel_id === 0x09) {

decoded.dout1 = bytes[i] === 0 ? "off" : "on";

i += 1;

}

// Digital Output 2

else if (channel_id === 0x0a) {

decoded.dout2 = bytes[i] === 0 ? "off" : "on";

i += 1;

}

// ADC 1

else if (channel_id === 0x11) {

decoded.adc1 = {};

decoded.adc1.cur = readInt16LE(bytes.slice(i, i + 2)) / 100;

decoded.adc1.min = readInt16LE(bytes.slice(i + 2, i + 4)) / 100;

decoded.adc1.max = readInt16LE(bytes.slice(i + 4, i + 6)) / 100;

decoded.adc1.avg = readInt16LE(bytes.slice(i + 6, i + 8)) / 100;

i += 8;

continue;

}

// ADC 2

else if (channel_id === 0x12) {

decoded.adc2 = {};

decoded.adc2.cur = readInt16LE(bytes.slice(i, i + 2)) / 100;

decoded.adc2.min = readInt16LE(bytes.slice(i + 2, i + 4)) / 100;

decoded.adc2.max = readInt16LE(bytes.slice(i + 4, i + 6)) / 100;

decoded.adc2.avg = readInt16LE(bytes.slice(i + 6, i + 8)) / 100;

i += 8;

continue;

}

// MODBUS

else if (channel_id === 0xFF && channel_type === 0x0E) {

var modbus_chn_id = bytes[i++];

var package_type = bytes[i++];

var data_type = package_type & 7;

var date_length = package_type >> 3;

var chn = 'chn' + modbus_chn_id;

switch (data_type) {

case 0:

decoded[chn] = bytes[i] ? "on" : "off";

i += 1;

break;

case 1:

decoded[chn] = bytes[i];

i += 1;

break;

case 2:

case 3:

decoded[chn] = readUInt16LE(bytes.slice(i, i + 2));

i += 2;

break;

case 4:

case 6:

decoded[chn] = readUInt32LE(bytes.slice(i, i + 4));

i += 4;

break;

case 5:

case 7:

decoded[chn] = readFloatLE(bytes.slice(i, i + 4));

i += 4;

break;

}

}

}

return decoded;

}

/* ******************************************

* bytes to number

********************************************/

function readUInt8LE(bytes) {

return (bytes & 0xFF);

}

function readInt8LE(bytes) {

var ref = readUInt8LE(bytes);

return (ref > 0x7F) ? ref - 0x100 : ref;

}

function readUInt16LE(bytes) {

var value = (bytes[1] << 8) + bytes[0];

return (value & 0xFFFF);

}

function readInt16LE(bytes) {

var ref = readUInt16LE(bytes);

return (ref > 0x7FFF) ? ref - 0x10000 : ref;

}

function readUInt32LE(bytes) {

var value = (bytes[3] << 24) + (bytes[2] << 16) + (bytes[1] << 8) + bytes[0];

return (value & 0xFFFFFFFF);

}

function readInt32LE(bytes) {

var ref = readUInt32LE(bytes);

return (ref > 0x7FFFFFFF) ? ref - 0x100000000 : ref;

}

function readFloatLE(bytes) {

// JavaScript bitwise operators yield a 32 bits integer, not a float.

// Assume LSB (least significant byte first).

var bits = bytes[3] << 24 | bytes[2] << 16 | bytes[1] << 8 | bytes[0];

var sign = (bits >>> 31 === 0) ? 1.0 : -1.0;

var e = bits >>> 23 & 0xff;

var m = (e === 0) ? (bits & 0x7fffff) << 1 : (bits & 0x7fffff) | 0x800000;

var f = sign * m * Math.pow(2, e - 150);

return f;

}

技术服务中心

星纵网关和节点连接LinkWAN

概述

准备

步骤