Page History

{
    "sensors": [
      24.5,
      24.5,
      24.8,
      24.5,
      24.3,
      24.8
    ],
    "success": true
}

parse_sint16(bytes, idx) {

    bytes = bytes.slice(idx || 0);
    var t = bytes[0] << 8 | bytes[1] << 0;
    if( (t & 1<<15) > 0){ // temp is negative (16bit 2's complement)
        t = ((~t)& 0xffff)+1; // invert 16bits & add 1 => now positive value
        t=t*-1;
    }
    return t;
}

function parse_uint16(bytes, idx) {
    bytes = bytes.slice(idx || 0);
    var t = bytes[0] << 8 | bytes[1] << 0;
    return t;
}

function parse_hex(bytes, idx, end) {
    var chars = "0123456789abcdef";
    bytes = bytes.slice(idx || 0, end || null);
    var s = "";
    for (var i=0; i<bytes.length; i++) {
        var byte = bytes[i];
        s += chars.charAt(byte>>4);
        s += chars.charAt(byte & 0xf);
    }
    return s;
}

function NB_ParseConfigQuery(input) {
    for (var key in input.d) {
        Device.setConfig(key, input.d[key]);
    }
    return null;
}

function DecoderPort1(bytes) {
    return {
        "version":readVersion(bytes),
        "temp": parse_sint16(bytes, 3) / 10,
        "vBat": parse_uint16(bytes, 5) / 1000,
    };
}

function DecoderPort2(bytes) {
    // Decode an uplink message from a buffer
    // (array) of bytes to an object of fields.
    var sensors = [];
    var success = false;

    var pos = 0;
    if ( bytes.length ) {
        pos+=1;
        success = bytes[0] !== 0;
    }
    var left = bytes.length - pos;
    while (left>=8) {
        var sensor = {
            //'id_': bytes.slice(pos, pos+6),
            'id': parse_hex(bytes, pos, pos+6),
            'temp': parse_sint16(bytes, pos+6) / 10.0
        };
        sensors.push(sensor);
        pos += 8;
        left = bytes.length 

- 

pos;
    }
    

// if (port === 1) decoded.led = bytes[0];

    var decoded = {};
    

decoded['success'] =

 success;
    decoded['sensors'] = sensors;
    

return decoded;
}

function DecoderPort3(bytes) {
    // Decode an uplink message from a buffer
    // (array) of bytes to an object of fields.
    var sensors = [];
 

 var success = false;

    var pos = 0;
    if ( bytes.length 

) {
    

pos+=1;

success = bytes

[0] !== 0

;
    

}
 

var 

left 

= bytes

.length - pos;
    

var 

nr=0;

    while (left>=2) {
      var 

temp = 

parse_sint16(bytes, pos) / 10.0
        sensors.push(temp);
       

pos += 

2;
    

    left = bytes.length - pos;

    }
    // if (port === 

1) decoded.led = bytes[

0];

    var 

decoded 

= 

{};
    decoded['success'] = success;
  

 decoded['sensors'] = sensors;
    

return 

decoded;
}

function readVersion(bytes, i) {
    if (bytes.length < 

3) {
        

return null;
    }
    return "v" + bytes[i] + "

."

 + bytes[i + 1] + "." + bytes[i + 2];
}

function 

decode_status_code(code) {
  switch 

(code) {
    case 0:
    

return "OK";
    default:
    

return "UNKNOWN";
  }
}

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";
  

}
}

function DecoderPort64(bytes) {
  // legacy format, firmware 4.x
  // Decode an uplink message from a buffer
  // (array) of bytes to an object of fields.
  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 = (parse_uint16(bytes, 9) / 1000) || 0.0;
  var temp = (parse_sint16(bytes, 11) / 10) || -0x8000;
  var app_data = bytes.slice(13);
  
  Device.setProperty("firmware", firmware);
  Device.setProperty("version", version);
  Device.setProperty("status_code", status_code);
  Device.setProperty("status_text", status_text);
  Device.setProperty("reboot_code", reboot_code);
  Device.setProperty("reboot_reason", reboot_reason);
  Device.setProperty("final_code", final_code);
  Device.setProperty("app_data", app_data);
  Device.setProperty("temperature", temp);
  Device.setProperty("voltage", vcc);
  
  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
  };
}

function Decoder(bytes, port) {
    switch (port) {
        

case 

1:
       

return 

DecoderPort1(bytes);
       

case 2:
    

 return DecoderPort2(bytes);
     

   case 3:
            return DecoderPort3(bytes);
        case 4:
            return "error: No sensors found";
        case 64:
            return DecoderPort64(bytes);
    }
    return {
    

  "error": "Invalid port",
    

   "port": port
    };
}

// Wrapper for Lobaro 

Platform
function 

Parse(

input)

 {
    // Decode an incoming 

message 

to an object of fields.
    var b 

= bytes(atob(input.data));
    
    

if (input.i && input.d) {
      // NB-IoT
     

 var decoded = {};
      decoded = 

input.d;
      decoded.address = input.i;
      decoded.fCnt = input.n;
     

      var 

query = input.q || "data";
     

switch 

(

query) {
      

case "config":
          

return 

NB_ParseConfigQuery(

input

);
        default:
    

}
      return decoded;
    }

 var decoded 

= Decoder(

b, input.fPort);

    decoded.rssi = input.rssi;
    

decoded.fCnt = 

input.

fCnt;

    return 

decoded;
}

// Wrapper for Loraserver / ChirpStack
function Decode(fPort, bytes) {
    return Decoder(

bytes, 

fPort);
}