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.

Local encoding and decodingBit-level packingEditable C output

Current example

21 bytes

SBD limit

340 bytes

Certus limit

100,000 bytes

0x5dbe258bf867204bffcb742554f592d3031301ff10

Build locally. Save your configuration when ready.

Field definitions, example values, generated hex, and C code are calculated locally. Download a JSON file to keep your work or load it again later. If you choose to email your configuration, your email address, name (optional), saved fields, and code are sent to Telemetry Station to deliver that email.

No account requiredJSON save and restore

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: value or length firstEnter an example to calculate its smallest length in the selected unit. Finish editing the length to generate a random valid value. The allowed range appears below each field.

Decimals: value or range firstEnter a decimal to infer a range and precision, or define your own range, accuracy, or length to generate an example. Inferred sizes fit this sample; choose bounds for future readings.

Text and bytes: value or cap firstAn example sets the content cap. Finish editing a cap to create a random example within it. The total includes a length prefix.

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

Live payload

21 bytes

Example

168 bits

Worst case

31 bytes

SBD maximum usage31 / 340 bytes

Hex payload

0x5dbe258bf867204bffcb742554f592d3031301ff10

Bit packing saves about 4 bytes versus the same example stored as ordinary byte-aligned values.

The example and worst-case payload fit the selected network.

Save and restore your payload

Load Configuration JSON

Loading replaces the current fields and code. Download your current configuration first if you want to keep it.

Size to priceCalculate SBD cost · 21 bytes

Decode · Inspect · Integrate

From hex to sensor values.

Paste the application payload from your firmware to inspect every field in definition order. Decoding uses the fields above and runs entirely in your browser.

Load a saved schema ↑

Message hex

Follow current example above as field values change

Accepts a leading 0x, spaces and newlines. Paste payload bytes only, without transport headers. Changing the schema reinterprets these bytes; use the exact schema used by the sending firmware.

Decoded 7 fields · 168 data bits · 0 zero padding bits

Byte inspector

21 bytes

Select a field below to highlight its bytes, including its length prefix. Click a byte to select its field; click again to cycle through fields sharing that byte.

Latitude

Bits [0, 25) · 25 bits
Fixed-width field · no alignment gap

Complete decoded value

32.87051

Decoded fields

Definition order · zero-based bit offsets · MSB first

Values decoded using the configured payload schema, with actual offsets.
#	Type	Decoded value	Bit offset	Bits used
1	Scaled decimal	32.87051	0	25
2	Scaled decimal	-117.24103	25	26
3	Unsigned integer	37	51	12
4	Signed integer	-27	63	16
5	Boolean	true	79	1
6	ASCII text	"BUOY-01"	80	60incl. 4-bit prefix
7	Raw bytes	01ff10	140	28incl. 4-bit prefix

Numeric values export as decimal strings to preserve precision, including 64-bit counters. Variable-length fields shift subsequent offsets according to their actual length. A successful decode checks this layout, lengths and padding; it does not verify message authenticity or identify a mismatched schema with the same layout.

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
 * https://telemetrystation.com/payload-optimizer
 *
 * 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 SBD cost · 21 bytes Activate a device