Free public developer tool

Payload Optimizer Tool

Turn readable sensor values into compact, bit-packed satellite telemetry messages. Define your fields, preview the exact hex, and generate an editable C payload builder.

Runs entirely in your browserBit-level packingEditable C output

Current example

21 bytes

SBD limit

340 bytes

Certus limit

100,000 bytes

0x5dbe258bf867204bffcb742554f592d3031301ff10

Your payload work stays in your browser.

Field definitions, example values, generated hex, and C code are calculated locally. The optimizer does not send or save that work, so Telemetry Station cannot see the payloads you build, the values you enter, or the code you generate.

No account requiredNothing to upload

Ordinary page requests may still produce standard infrastructure logs as described in the Privacy Policy.

1 · Choose a transport

Set the payload limit

The optimizer checks both your example message and the worst-case field sizes against the selected Iridium transport.

2 · Define the message

Configure payload fields

Fields are encoded from top to bottom. Reorder them deliberately: a future parser must use this same schema and order.

Integers: choose the lengthThe length is the fixed number of bits or bytes used in every message. The allowed whole-number range is shown below each field.

Decimals: choose the rangeEnter real-world minimum and maximum values plus the smallest step. The required bit allocation is calculated for you.

Text and bytes: choose a capThe maximum content length reserves the worst case. Shorter values consume fewer bits because their length is encoded.

Latitude

latitude · Decimal / float

Drag

Example value

32.87051

Encoding

25 bits

Status

Ready

Longitude

longitude · Decimal / float

Drag

Example value

-117.24103

Encoding

26 bits

Status

Ready

Message sequence

message_sequence · Unsigned integer

Drag

Example value

Encoding

12 bits

Status

Ready

Temperature (tenths °C)

temperature_tenths_c · Signed integer

Drag

Example value

-27

Encoding

16 bits

Status

Ready

GPS fix

gps_fix · Boolean

Drag

Example value

true

Encoding

1 bit

Status

Ready

Device ID

device_id · ASCII text

Drag

Example value

BUOY-01

Encoding

100 bits

Status

Ready

Diagnostic bytes

diagnostic_bytes · Raw bytes

Drag

Example value

01ff10

Encoding

68 bits

Status

Ready

3 · Build the payload

Editable C program

The example variables are defined at the top of main. Edit the generated starter code here, copy it, or download a .c file.

telemetry_payload.c

Editable

/*
 * Telemetry Station Payload Optimizer Tool
 * Target: Iridium SBD (340 byte maximum)
 * Fields are packed from most-significant bit to least-significant bit
 * in the exact order shown below. The final byte is zero-padded.
 *
 * Maximum layout:
 * 01. latitude: 25 max bits; max offset 0
 * 02. longitude: 26 max bits; max offset 25
 * 03. message_sequence: 12 max bits; max offset 51
 * 04. temperature_tenths_c: 16 max bits; max offset 63
 * 05. gps_fix: 1 max bits; max offset 79
 * 06. device_id: 100 max bits (length-prefixed); max offset 80
 * 07. diagnostic_bytes: 68 max bits (length-prefixed); max offset 180
 *
 * Build: cc -std=c11 -Wall -Wextra -pedantic payload.c -lm -o payload
 */

#include <stdbool.h>
#include <stdint.h>
#include <inttypes.h>
#include <math.h>
#include <stdio.h>
#include <string.h>

#define MAX_PAYLOAD_BYTES 340u

bool write_bits(
    uint8_t *output,
    size_t capacity_bytes,
    size_t *bit_position,
    uint64_t value,
    size_t bit_count
) {
    if (bit_count > 64u || *bit_position + bit_count > capacity_bytes * 8u) {
        return false;
    }

for (size_t offset = 0; offset < bit_count; ++offset) {
        const size_t shift = bit_count - 1u - offset;
        const size_t byte_index = *bit_position / 8u;
        const size_t bit_index = 7u - (*bit_position % 8u);
        const uint8_t bit = (uint8_t)((value >> shift) & UINT64_C(1));
        output[byte_index] |= (uint8_t)(bit << bit_index);
        *bit_position += 1u;
    }

return true;
}

bool write_unsigned(
    uint8_t *output,
    size_t capacity_bytes,
    size_t *bit_position,
    uint64_t value,
    size_t bit_count
) {
    if (bit_count == 0u || bit_count > 64u) return false;
    if (bit_count < 64u && value > ((UINT64_C(1) << bit_count) - UINT64_C(1))) {
        return false;
    }
    return write_bits(output, capacity_bytes, bit_position, value, bit_count);
}

bool write_signed(
    uint8_t *output,
    size_t capacity_bytes,
    size_t *bit_position,
    int64_t value,
    size_t bit_count
) {
    if (bit_count < 2u || bit_count > 64u) return false;

if (bit_count < 64u) {
        const int64_t minimum = -(INT64_C(1) << (bit_count - 1u));
        const int64_t maximum = (INT64_C(1) << (bit_count - 1u)) - INT64_C(1);
        if (value < minimum || value > maximum) return false;
    }

const uint64_t encoded = (uint64_t)value;
    const uint64_t masked =
        bit_count == 64u ? encoded : encoded & ((UINT64_C(1) << bit_count) - UINT64_C(1));
    return write_bits(output, capacity_bytes, bit_position, masked, bit_count);
}

uint64_t power_of_ten(size_t decimal_places) {
    uint64_t result = UINT64_C(1);
    for (size_t index = 0; index < decimal_places; ++index) result *= UINT64_C(10);
    return result;
}

bool write_scaled_float(
    uint8_t *output,
    size_t capacity_bytes,
    size_t *bit_position,
    double value,
    double minimum,
    double maximum,
    size_t decimal_places,
    size_t bit_count
) {
    if (!isfinite(value) || value < minimum || value > maximum) return false;
    const uint64_t scale = power_of_ten(decimal_places);
    const uint64_t scaled = (uint64_t)llround((value - minimum) * (double)scale);
    return write_bits(output, capacity_bytes, bit_position, scaled, bit_count);
}

bool write_sized_bytes(
    uint8_t *output,
    size_t capacity_bytes,
    size_t *bit_position,
    const uint8_t *value,
    size_t value_length,
    size_t maximum_bytes,
    size_t length_bits
) {
    if (value_length > maximum_bytes) return false;
    if (!write_bits(output, capacity_bytes, bit_position, (uint64_t)value_length, length_bits)) {
        return false;
    }
    for (size_t index = 0; index < value_length; ++index) {
        if (!write_bits(output, capacity_bytes, bit_position, value[index], 8u)) return false;
    }
    return true;
}

bool write_sized_ascii(
    uint8_t *output,
    size_t capacity_bytes,
    size_t *bit_position,
    const char *value,
    size_t maximum_bytes,
    size_t length_bits
) {
    const size_t value_length = strlen(value);
    for (size_t index = 0; index < value_length; ++index) {
        if ((unsigned char)value[index] > 0x7fu) return false;
    }
    return write_sized_bytes(
        output, capacity_bytes, bit_position, (const uint8_t *)value,
        value_length, maximum_bytes, length_bits
    );
}

int main(void) {
    /* Edit these example sensor values. */
    const double latitude = 32.87051;
    const double longitude = -117.24103;
    const uint64_t message_sequence = UINT64_C(37);
    const int64_t temperature_tenths_c = -INT64_C(27);
    const bool gps_fix = true;
    const char device_id[] = "BUOY-01";
    const uint8_t diagnostic_bytes[] = { 0x01, 0xff, 0x10 };
    const size_t diagnostic_bytes_length = 3u;

uint8_t payload[MAX_PAYLOAD_BYTES] = {0};
    size_t bit_position = 0u;

if (!write_scaled_float(payload, sizeof(payload), &bit_position, latitude, -90.0, 90.0, 5u, 25u)) {
        fputs("Could not encode Latitude.\n", stderr);
        return 1;
    }
    if (!write_scaled_float(payload, sizeof(payload), &bit_position, longitude, -180.0, 180.0, 5u, 26u)) {
        fputs("Could not encode Longitude.\n", stderr);
        return 1;
    }
    if (!write_unsigned(payload, sizeof(payload), &bit_position, message_sequence, 12u)) {
        fputs("Could not encode Message sequence.\n", stderr);
        return 1;
    }
    if (!write_signed(payload, sizeof(payload), &bit_position, temperature_tenths_c, 16u)) {
        fputs("Could not encode Temperature (tenths °C).\n", stderr);
        return 1;
    }
    if (!write_bits(payload, sizeof(payload), &bit_position, gps_fix ? UINT64_C(1) : UINT64_C(0), 1u)) {
        fputs("Could not encode GPS fix.\n", stderr);
        return 1;
    }
    if (!write_sized_ascii(payload, sizeof(payload), &bit_position, device_id, 12u, 4u)) {
        fputs("Could not encode Device ID.\n", stderr);
        return 1;
    }
    if (!write_sized_bytes(payload, sizeof(payload), &bit_position, diagnostic_bytes, diagnostic_bytes_length, 8u, 4u)) {
        fputs("Could not encode Diagnostic bytes.\n", stderr);
        return 1;
    }

const size_t payload_bytes = (bit_position + 7u) / 8u;
    for (size_t index = 0; index < payload_bytes; ++index) {
        printf("%02x", payload[index]);
    }
    printf("\n%zu bits / %zu bytes\n", bit_position, payload_bytes);
    return 0;
}

Generated code is a transparent starting point. Validate the byte order and schema against your receiving decoder before deploying it to production firmware.

Ready to deploy?

Price and activate your Iridium service.

Use the optimized payload size in the Telemetry Station calculator to estimate the right plan for your deployment.

Calculate my cost Activate a device