Device API Documentation

Byte 0: 0x33 (51 decimal)
Byte 1: 0x01 (1 decimal)

Byte 2: Device Version (13, 23, 27, 41, 42, or 43)

Find position where byte == 0xFF (255)
Start parsing at position + 1

const battery = data[pos + 3];
const interval = (data[pos + 4] << 8) | data[pos + 5];
const logCount = (data[pos + 6] << 8) | data[pos + 7];
const tempRaw = (data[pos + 8] << 8) | data[pos + 9];
const temperature = (tempRaw > 32767 ? tempRaw - 65536 : tempRaw) / 10;

function calculateDewpoint(tempC, humidityPct) {
    const a = 17.27;
    const b = 237.7;
    const alpha = ((a * tempC) / (b + tempC)) + Math.log(humidityPct / 100);
    return (b * alpha) / (a - alpha);
}

Service UUID:        6E400001-B5A3-F393-E0A9-E50E24DCCA9E
RX Characteristic:   6E400002-B5A3-F393-E0A9-E50E24DCCA9E  (Write - App to Device)
TX Characteristic:   6E400003-B5A3-F393-E0A9-E50E24DCCA9E  (Notify - Device to App)

Service UUID:        6E400001-9489-44E4-9E39-60BA18464A30
Indicator:           6E400002-9489-44E4-9E39-60BA18464A30  (Notify)

<command>~<value>

*logall              // Download all logs (disconnects after)
*logtemp100          // Download temp logs from record 100
*loghumi0            // Download all humidity logs
*logntemp50          // Download temp logs, stay connected

*lint60              // Log every 60 seconds
*lint3600            // Log every hour
*namMyDisc           // Set device name to "MyDisc"
*txp0                // Set to +4 dBm (max range)
*pwd1234             // Set/enter password

// Format: *alrm<1|2><t|h|d><operator><value>
// Operators: > (above), < (below), = (equals)

*alrm1t>25           // Alarm 1: temp above 25°C
*alrm2t<10           // Alarm 2: temp below 10°C
*alrm1h>80           // Alarm 1: humidity above 80%

airplane         // No value needed
Response: OK: Airplane mode toggled

pin~1234    // Set PIN to 1234 (locks device)
pin~5678    // If locked with 1234, this fails
pin~1234    // If already locked with 1234, unlocks and clears PIN

Response:
- OK: New PIN set and device locked
- OK: Device unlocked successfully and PIN cleared
- ERR: Incorrect PIN

setlog~60        // Log every 60 seconds (1 minute)
setlog~3600      // Log every hour
Response: OK: Logging interval updated successfully

// Side effects: Resets log counters, clears buffer memory

// Version 41 (temperature only)
wcal~-50         // Temp offset -0.50°C (-0.90°F)

// Version 42 (temperature + humidity)
wcal~-50,25      // Temp -0.50°C, Humidity +0.25%

// Version 43 (temperature + humidity + pressure)
wcal~-50,25,100  // Temp -0.50°C, Humidity +0.25%, Pressure +1.00 hPa

// Values multiplied by 100 (e.g., -50 = -0.50°C)
Response: OK: Calibrations updated

// Modern devices (v41-43)
logall      // Download all logs
log~100     // Download last 100 logs

// Legacy devices (v13-27)
*logall     // Download all logs

// Response: Binary data stream, terminated with '..'
// Note: Only one download per connection

txpwr~4      // +4 dBm (maximum range ~246ft / 75m)
txpwr~0      // 0 dBm
txpwr~-4     // -4 dBm
txpwr~-8     // -8 dBm (minimum power)
Response: OK: TX Power updated successfully

// Modern devices (v41, v42, v43)
command = "logall";  // Full download
command = "log~100"; // Last 100 logs

// Legacy devices (v13, v23, v27)
command = "*logall"; // Full download

function parseV41Reading(data, offset) {
    const temp = (data[offset + 1] << 8) | data[offset];
    // Convert to signed int16
    const temperature = temp > 32767 ? temp - 65536 : temp;
    // temperature is in 0.01C (divide by 100 for display)
    return { temperature };
}

function parseV42Reading(data, offset) {
    const temp = toInt16(data[offset], data[offset + 1]);
    const hum = toInt16(data[offset + 2], data[offset + 3]);
    const dew = calculateDewpoint(temp / 100, hum / 100) * 100;
    return { temperature: temp, humidity: hum, dewpoint: Math.round(dew) };
}

function toInt16(low, high) {
    let value = (high << 8) | low;
    return value > 32767 ? value - 65536 : value;
}

function parseV43Reading(data, offset) {
    const temp = toInt16(data[offset], data[offset + 1]);
    const hum = toInt16(data[offset + 2], data[offset + 3]);
    const press = toInt32(data[offset + 4], data[offset + 5],
                          data[offset + 6], data[offset + 7]);
    const dew = calculateDewpoint(temp / 100, hum / 100) * 100;
    return {
        temperature: temp,
        humidity: hum,
        pressure: press,
        dewpoint: Math.round(dew)
    };
}

function calculateTimestamps(readings, referenceUnix, intervalSeconds) {
    return readings.map((reading, index) => ({
        ...reading,
        unix: referenceUnix + (index * intervalSeconds * 1000)
    }));
}

Service UUID:        6E400001-9489-44E4-9E39-60BA18464A30
Characteristic UUID: 6E400002-9489-44E4-9E39-60BA18464A30

// Version 41: 6 bytes
typedef struct __packed {
    int16_t temperature;    // 2 bytes (temp × 100)
    uint8_t mac_address[4]; // 4 bytes (last 4 of MAC)
} alert_data_v41_t;

// Version 42: 8 bytes
typedef struct __packed {
    int16_t temperature;    // 2 bytes
    int16_t humidity;       // 2 bytes
    uint8_t mac_address[4]; // 4 bytes
} alert_data_v42_t;

// Version 43: 12 bytes
typedef struct __packed {
    int16_t temperature;    // 2 bytes
    int16_t humidity;       // 2 bytes
    int32_t pressure;       // 4 bytes
    uint8_t mac_address[4]; // 4 bytes
} alert_data_v43_t;

// Version 41 Reading
interface Device41Reading {
    index: number;       // Reading sequence number
    unix: number;        // Timestamp (milliseconds)
    temperature: number; // Raw value (/100 for C)
}

// Version 42 Reading
interface Device42Reading {
    index: number;
    unix: number;
    temperature: number; // Raw value (/100 for C)
    humidity: number;    // Raw value (/100 for %RH)
    dewpoint: number;    // Calculated (/100 for C)
}

// Version 43 Reading
interface Device43Reading {
    index: number;
    unix: number;
    temperature: number; // Raw value (/100 for C)
    humidity: number;    // Raw value (/100 for %RH)
    pressure: number;    // Raw value (Pa)
    dewpoint: number;    // Calculated (/100 for C)
}

// Celsius to Fahrenheit
function celsiusToFahrenheit(celsius) {
    return (celsius * 9/5) + 32;
}

// Fahrenheit to Celsius
function fahrenheitToCelsius(fahrenheit) {
    return (fahrenheit - 32) * 5/9;
}

// Pascal to hPa (hectopascal/millibar)
function paToHpa(pa) {
    return pa / 100;
}

// hPa to inHg (inches of mercury)
function hpaToInhg(hpa) {
    return hpa * 0.02953;
}

function calculateDewpoint(temperatureCelsius, humidityPercent) {
    const a = 17.27;
    const b = 237.7;
    const alpha = ((a * temperatureCelsius) / (b + temperatureCelsius)) +
                  Math.log(humidityPercent / 100);
    return (b * alpha) / (a - alpha);
}

1. Connect to device
2. Subscribe to RX characteristic
3. Write "info" to TX characteristic
4. Read response from RX notification
5. Parse text response
6. Disconnect

1. Connect to device
2. Subscribe to RX characteristic
3. Write "log~all" to TX characteristic
4. Receive binary stream of sensor data
5. Parse based on device version (check advertisement data)
6. Convert: value / 100.0 for actual reading
7. Device disconnects when complete

1. Connect to device
2. Check if locked (send "info", check response)
3. If locked, send "pin~<PIN>" to unlock
4. Send "setlog~300" (5 minute logging)
5. Send calibration command (version-specific)
6. Send "name~MyDevice"
7. Disconnect

# Connect to device (using bleak library)
device = ble.connect("Device_MAC_ADDRESS")
service = device.get_service(NUS_SERVICE_UUID)
tx_char = service.get_characteristic(NUS_TX_UUID)
rx_char = service.get_characteristic(NUS_RX_UUID)

# Enable notifications
rx_char.enable_notifications(on_data_received)

# Send command
def send_command(command):
    tx_char.write(command.encode())

# Receive response
def on_data_received(data):
    print(f"Response: {data.decode()}")

# Example: Get device info
send_command("info")
time.sleep(1)  # Wait for response

# Disconnect
device.disconnect()

import struct

# Parse log data - VERSION SPECIFIC
def parse_logs_v41(data):
    logs = []
    for i in range(0, len(data), 2):
        temp = struct.unpack('<h', data[i:i+2])[0]
        temp_c = temp / 100.0
        temp_f = temp_c * 9/5 + 32
        logs.append({'temperature_c': temp_c, 'temperature_f': temp_f})
    return logs

def parse_logs_v42(data):
    logs = []
    for i in range(0, len(data), 4):
        temp, humi = struct.unpack('<hh', data[i:i+4])
        logs.append({
            'temperature_c': temp / 100.0,
            'temperature_f': (temp / 100.0) * 9/5 + 32,
            'humidity': humi / 100.0
        })
    return logs

def parse_logs_v43(data):
    logs = []
    for i in range(0, len(data), 8):
        temp, humi, press = struct.unpack('<hhi', data[i:i+8])
        logs.append({
            'temperature_c': temp / 100.0,
            'temperature_f': (temp / 100.0) * 9/5 + 32,
            'humidity': humi / 100.0,
            'pressure_hpa': press / 100.0,
            'pressure_inhg': (press / 100.0) * 0.02953
        })
    return logs