Thingsee CBOR to JSON Conversion

[{
    "tsmId": 13100,
    "tsmEv": 10,
    "tsmTs": 1492603998,
    "tsmTuid": "TSPR04123456",
    "tsmGw": "TSGW2G987654",
    "tsmAp": "occupancy-monitoring",
    "moveCount": 7
}]

[{1: 13100, 2: 10, 44: 7}]

[{
  "tsmId": 13100,
  "tsmEv": 10,
  "moveCount": 7
}]

[{
  "tsmId": 13100,
  "tsmEv": 10,
  "tsmTs": 1492844596,
  "tsmTuid": "TSPR04123456",
  "tsmGw": "TSGW2G987654",
  "moveCount": 7
}]

[{1: 28009, 2: 7, 1279: 1569, 38: 1, 45: 1600}]

[{
  "tsmId": 28009,
  "tsmEv": 7,
  "echo": 1569,
  "state": 1,
  "dist": 1600
}]

[{
  "tsmId": 28009,
  "tsmEv": 7,
  "tsmTs": 1492844596,
  "tsmTuid": "TSRAD5123456",
  "dist": 1600,
  "echo": 1569,
  "state": 1
}]

{
  "tsmId": 1500,
  "tsmEv": 30,
  "transactionId": 1485925806,
  "measurementInterval": 30,
  "reportInterval": 300
}

{1: 1500, 2: 30, 25: 1485925806, 256: 30, 258: 300}

import cbor2
import struct
from datetime import datetime

# CBOR index to JSON property mapping
CBOR_INDEX_MAP = {
    # Header
    1: "tsmId",
    2: "tsmEv",
    3: "tsmTs",
    4: "tsmTuid",
    5: "tsmGw",
    6: "tsmAp",
    7: "tsmDstTuid",
    8: "tsmGwTs",
    9: "tsmCloudTs",
    
    # Common data fields
    20: "pwr",
    21: "batl",
    22: "chrg",
    23: "requestTsmId",
    24: "timestamp",
    25: "transactionId",
    26: "uptime",
    27: "status",
    
    # Sensor measurements
    30: "temp",
    31: "lght",
    32: "humd",
    33: "airp",
    34: "level",
    35: "min",
    36: "max",
    37: "mode",
    38: "state",
    39: "pressure",
    
    # Motion
    40: "accx",
    41: "accy",
    42: "accz",
    43: "move",
    44: "moveCount",
    45: "dist",
    46: "hall",
    47: "hallCount",
    48: "switch",
    49: "switchCount",
    56: "gforce",
    57: "gforceMax",
    
    # Network
    59: "voltage",
    60: "wpnode",
    61: "rssi",
    62: "tuid",
    65: "rssiDbm",
    70: "swVersion",
    71: "modelCode",
    
    # Activity
    81: "activityLevel",
    89: "energyLevel",
    
    # Configuration
    256: "measurementInterval",
    257: "measurementFrequency",
    258: "reportInterval",
    259: "impactThresholdMin",
    260: "impactThresholdMax",
    261: "idleInterval",
    262: "accelerometerMode",
    263: "threshold",
    264: "enableLed",
    
    # Air quality
    283: "carbonDioxide",
    284: "tvoc",
    
    # Histogram
    1000: "histogram0",
    1001: "histogram1",
    1002: "histogram2",
    1003: "histogram3",
    1004: "histogram4",
    1005: "histogram5",
    1006: "histogram6",
    1007: "histogram7",
    1008: "histogram8",
    1009: "histogram9",
    
    # People counting
    1210: "in",
    1211: "out",
}

# Multipliers for fields requiring decimal conversion
MULTIPLIERS = {
    "batl": 1,
    "temp": 1,
    "humd": 1,
    "airp": 3,
    "pressure": 3,
    "voltage": 6,
    "activityLevel": 3,
    "impactThresholdMax": 1,
    "angle": 1,
    "tempMin": 1,
    "tempMax": 1,
    "humdMin": 1,
    "humdMax": 1,
    "temperatureHysteresis": 1,
    "humidityHysteresis": 1,
    "pressureHysteresis": 3,
    "activityLevelThreshold": 3,
}

def decode_cbor_message(binary_payload):
    """
    Decode CBOR binary payload to JSON structure.
    
    Args:
        binary_payload: bytes - Raw CBOR binary data
        
    Returns:
        dict - Decoded message with JSON property names
    """
    try:
        # Decode CBOR to Python dict
        cbor_data = cbor2.loads(binary_payload)
        
        # Handle array wrapper (messages typically come as single-element arrays)
        if isinstance(cbor_data, list):
            cbor_data = cbor_data[0] if len(cbor_data) > 0 else {}
        
        # Convert CBOR indexes to JSON property names
        json_message = {}
        for cbor_index, value in cbor_data.items():
            # Get JSON property name
            prop_name = CBOR_INDEX_MAP.get(cbor_index, f"unknown_{cbor_index}")
            
            # Apply multiplier if needed
            if prop_name in MULTIPLIERS:
                multiplier = MULTIPLIERS[prop_name]
                value = value / (10 ** multiplier)
            
            json_message[prop_name] = value
        
        return json_message
        
    except Exception as e:
        print(f"Error decoding CBOR: {e}")
        return None

def add_gateway_fields(json_message, wirepas_node_id, gateway_id, network_timestamp):
    """
    Add gateway-originated fields to sensor message.
    
    Args:
        json_message: dict - Decoded sensor message
        wirepas_node_id: int - Wirepas node ID
        gateway_id: str - Gateway identifier
        network_timestamp: int - Wirepas network timestamp
        
    Returns:
        dict - Complete message with gateway fields
    """
    # Add timestamp (convert Wirepas time to UTC)
    json_message["tsmTs"] = network_timestamp
    
    # Add device identifier (lookup serial from node ID mapping)
    # In production, query device database with wirepas_node_id
    json_message["tsmTuid"] = f"NODE{wirepas_node_id}"
    
    # Add gateway identifier
    json_message["tsmGw"] = gateway_id
    
    return json_message

# Example usage
if __name__ == "__main__":
    # Example: Thingsee PRESENCE movement message
    hex_message = "9fa3011933 2c020a182c07ff"
    binary_payload = bytes.fromhex(hex_message.replace(" ", ""))
    
    # Decode
    message = decode_cbor_message(binary_payload)
    print("Decoded message:", message)
    # Output: {'tsmId': 13100, 'tsmEv': 10, 'moveCount': 7}
    
    # Add gateway fields
    complete_message = add_gateway_fields(
        message,
        wirepas_node_id=123456,
        gateway_id="TSGW2G987654",
        network_timestamp=1492844596
    )
    print("Complete message:", complete_message)

const cbor = require('cbor');

// CBOR index to JSON property mapping
const CBOR_INDEX_MAP = {
  // Header
  1: 'tsmId',
  2: 'tsmEv',
  3: 'tsmTs',
  4: 'tsmTuid',
  5: 'tsmGw',
  6: 'tsmAp',
  7: 'tsmDstTuid',
  8: 'tsmGwTs',
  9: 'tsmCloudTs',
  
  // Common data fields
  20: 'pwr',
  21: 'batl',
  22: 'chrg',
  23: 'requestTsmId',
  24: 'timestamp',
  25: 'transactionId',
  26: 'uptime',
  27: 'status',
  
  // Sensor measurements
  30: 'temp',
  31: 'lght',
  32: 'humd',
  33: 'airp',
  38: 'state',
  44: 'moveCount',
  45: 'dist',
  
  // Add more mappings as needed...
  
  // People counting
  1210: 'in',
  1211: 'out'
};

// Multipliers for decimal conversion
const MULTIPLIERS = {
  batl: 1,
  temp: 1,
  humd: 1,
  airp: 3,
  voltage: 6,
  activityLevel: 3,
  angle: 1
};

/**
 * Decode CBOR binary payload to JSON structure
 * @param {Buffer} binaryPayload - Raw CBOR binary data
 * @returns {Object} Decoded message with JSON property names
 */
function decodeCborMessage(binaryPayload) {
  try {
    // Decode CBOR to JavaScript object
    let cborData = cbor.decodeFirstSync(binaryPayload);
    
    // Handle array wrapper
    if (Array.isArray(cborData)) {
      cborData = cborData.length > 0 ? cborData[0] : {};
    }
    
    // Convert CBOR indexes to JSON property names
    const jsonMessage = {};
    for (const [cborIndex, value] of Object.entries(cborData)) {
      const index = parseInt(cborIndex);
      
      // Get JSON property name
      const propName = CBOR_INDEX_MAP[index] || `unknown_${index}`;
      
      // Apply multiplier if needed
      let finalValue = value;
      if (propName in MULTIPLIERS) {
        const multiplier = MULTIPLIERS[propName];
        finalValue = value / Math.pow(10, multiplier);
      }
      
      jsonMessage[propName] = finalValue;
    }
    
    return jsonMessage;
    
  } catch (error) {
    console.error('Error decoding CBOR:', error);
    return null;
  }
}

/**
 * Add gateway-originated fields to sensor message
 * @param {Object} jsonMessage - Decoded sensor message
 * @param {number} wirepasNodeId - Wirepas node ID
 * @param {string} gatewayId - Gateway identifier
 * @param {number} networkTimestamp - Wirepas network timestamp
 * @returns {Object} Complete message with gateway fields
 */
function addGatewayFields(jsonMessage, wirepasNodeId, gatewayId, networkTimestamp) {
  // Add timestamp
  jsonMessage.tsmTs = networkTimestamp;
  
  // Add device identifier (lookup from database in production)
  jsonMessage.tsmTuid = `NODE${wirepasNodeId}`;
  
  // Add gateway identifier
  jsonMessage.tsmGw = gatewayId;
  
  return jsonMessage;
}

// Example usage
const hexMessage = '9fa3011933 2c020a182c07ff';
const binaryPayload = Buffer.from(hexMessage.replace(/\s/g, ''), 'hex');

// Decode
const message = decodeCborMessage(binaryPayload);
console.log('Decoded message:', message);
// Output: { tsmId: 13100, tsmEv: 10, moveCount: 7 }

// Add gateway fields
const completeMessage = addGatewayFields(
  message,
  123456,
  'TSGW2G987654',
  1492844596
);
console.log('Complete message:', completeMessage);

import zlib
import cbor2

def decode_compressed_cbor(binary_payload):
    try:
        # Decompress with zlib
        decompressed = zlib.decompress(binary_payload)
        
        # Decode CBOR
        cbor_data = cbor2.loads(decompressed)
        
        # Process as normal...
        return cbor_data
        
    except zlib.error:
        # Not compressed, decode directly
        return cbor2.loads(binary_payload)

const pako = require('pako');
const cbor = require('cbor');

function decodeCompressedCbor(binaryPayload) {
  try {
    // Try decompression
    const decompressed = pako.inflate(binaryPayload);
    const cborData = cbor.decodeFirstSync(Buffer.from(decompressed));
    return cborData;
  } catch (error) {
    // Not compressed, decode directly
    return cbor.decodeFirstSync(binaryPayload);
  }
}

query DeviceByWirepasNode($nodeId: Int!) {
  devices(where: {identifiers: {wirepasNodeId: {_eq: $nodeId}}}) {
    id
    name
    identifiers {
      wirepasNodeId
      vendorSerial
    }
    deviceType {
      productName
    }
  }
}