Milesight VS121: AI Workplace Occupancy & People Counter

function decodeUplink(input) {
  var bytes = input.bytes;
  var data = { regions: {} };

  for (var i = 0; i < bytes.length; ) {
    var channel = bytes[i++];
    var type = bytes[i++];

    // Device info (join / power-on): version, serial, hw/fw
    if (channel === 0xff) {
      if (type === 0x01) { data.protocol_version = bytes[i]; i += 1; }
      else if (type === 0x08) { i += 6; }   // serial number
      else if (type === 0x09) { i += 2; }   // hardware version
      else if (type === 0x1f) { i += 4; }   // firmware version
      else { break; }
      continue;
    }

    // People counter: total + region count + 16-bit region occupancy mask (UINT16 BE)
    if (channel === 0x04 && type === 0xc9) {
      data.people_count_all = bytes[i];
      var regionCount = bytes[i + 1];
      var mask = readUInt16BE(bytes, i + 2);
      for (var r = 0; r < regionCount; r++) {
        data.regions["region_" + (r + 1)] = (mask >> r) & 1;
      }
      i += 4; continue;
    }

    // Cumulative people in / out (INT16 LE)
    if (channel === 0x05 && type === 0xcc) {
      data.people_in = readInt16LE(bytes, i);
      data.people_out = readInt16LE(bytes, i + 2);
      i += 4; continue;
    }

    // Periodic maximum people count
    if (channel === 0x06 && type === 0xcd) {
      data.people_count_max = bytes[i];
      i += 1; continue;
    }

    // Total people in / out (UINT16 LE)
    if (channel === 0x0d && type === 0xcc) {
      data.people_total_in = readUInt16LE(bytes, i);
      data.people_total_out = readUInt16LE(bytes, i + 2);
      i += 4; continue;
    }

    // Dwell time: region (1) + avg (UINT16) + max (UINT16)
    if (channel === 0x0e && type === 0xe4) {
      data.dwell_region = bytes[i];
      data.dwell_time_avg = readUInt16LE(bytes, i + 1);
      data.dwell_time_max = readUInt16LE(bytes, i + 3);
      i += 5; continue;
    }

    // Timestamp (UINT32 LE)
    if (channel === 0x0f && type === 0x85) {
      data.timestamp = readUInt32LE(bytes, i);
      i += 4; continue;
    }

    // Directional line in / out (UINT16 LE)
    if (channel === 0x10 && type === 0xf7) {
      data.line_in = readUInt16LE(bytes, i);
      data.line_out = readUInt16LE(bytes, i + 2);
      i += 4; continue;
    }

    // Region counters (0x07/0x08, type 0xd5): 8 bytes, one per region
    if ((channel === 0x07 || channel === 0x08) && type === 0xd5) {
      var base = channel === 0x07 ? 0 : 8;
      for (var k = 0; k < 8; k++) {
        data.regions["region_" + (base + k + 1) + "_count"] = bytes[i + k];
      }
      i += 8; continue;
    }

    // A/B/C/D flow matrices (0x09-0x0c, type 0xda): 4 x UINT16 LE
    if (channel >= 0x09 && channel <= 0x0c && type === 0xda) {
      i += 8; continue;
    }

    // Unknown / history / downlink-response channel: stop here
    break;
  }
  return { data: data };
}

function readUInt16LE(b, i) {
  return ((b[i + 1] << 8) | b[i]) & 0xffff;
}
function readUInt16BE(b, i) {
  return ((b[i] << 8) | b[i + 1]) & 0xffff;
}
function readInt16LE(b, i) {
  var v = readUInt16LE(b, i);
  return v > 0x7fff ? v - 0x10000 : v;
}
function readUInt32LE(b, i) {
  return ((b[i+3]<<24)|(b[i+2]<<16)|(b[i+1]<<8)|b[i]) >>> 0;
}