CCSDS Space Packet Protocol¶

// Example: Temperature housekeeping packet
// APID = 0x001, Type = TM, Seq Count increments each packet
Header: [Ver=0][Type=0][SecHdr=1][APID=0x001][Seq=3][Flags=11][Len=31]
Secondary Header: [Timestamp: 4 bytes coarse + 2 bytes fine]
Data: [Temp1: 2B][Temp2: 2B][Temp3: 2B]...[TempN: 2B]
CRC-16: [2 bytes]

// Example: Set heater ON command
// APID = 0x001, Type = TC, Sequence = next in TC sequence
Header: [Ver=0][Type=1][SecHdr=1][APID=0x001][Seq=47][Flags=11][Len=9]
Secondary Header: [Ack flags: 1B][Service Type: 1B][Subtype: 1B]
Data: [Heater ID: 1B][State: 1B (ON=1)]
CRC-16: [2 bytes]

#include "ccsds_spp.h"

typedef enum {
    SPP_TYPE_TM = 0,    // Telemetry
    SPP_TYPE_TC = 1     // Telecommand
} spp_packet_type_t;

typedef enum {
    SPP_SEQ_CONTINUATION = 0b00,
    SPP_SEQ_FIRST        = 0b01,
    SPP_SEQ_LAST         = 0b10,
    SPP_SEQ_UNSEGMENTED  = 0b11
} spp_seq_flags_t;

typedef struct {
    uint8_t            version;       // Always 0
    spp_packet_type_t  type;          // TM or TC
    bool               sec_hdr_flag;  // Secondary header present
    uint16_t           apid;          // 0–2047
    spp_seq_flags_t    seq_flags;     // Segmentation
    uint16_t           seq_count;     // 0–16383
    uint16_t           data_length;   // Data zone length - 1
} spp_header_t;

typedef struct {
    spp_header_t  header;
    uint8_t      *data;              // Pointer to data zone
    size_t        data_size;         // Actual data size (data_length + 1)
    uint16_t      crc;              // CRC-16-CCITT (if present)
    bool          crc_valid;        // CRC verification result
} spp_packet_t;

// Encode packet structure to wire format
// Returns total packet size written, or -1 on error
ssize_t spp_encode(const spp_packet_t *packet, uint8_t *buffer, 
                   size_t buf_size);

// Decode wire format to packet structure
// Returns bytes consumed, or -1 on error
ssize_t spp_decode(const uint8_t *buffer, size_t buf_size,
                   spp_packet_t *packet);

// Encode only the 6-byte primary header
void spp_encode_header(const spp_header_t *header, uint8_t out[6]);

// Decode only the 6-byte primary header
void spp_decode_header(const uint8_t buf[6], spp_header_t *header);

// Compute CRC-16-CCITT over buffer
uint16_t spp_crc16(const uint8_t *data, size_t len);

// Verify packet CRC (assumes CRC is last 2 bytes of data zone)
bool spp_verify_crc(const spp_packet_t *packet);

// Append CRC to packet data zone
void spp_append_crc(spp_packet_t *packet);

// Per-APID sequence counter (thread-safe)
typedef struct {
    uint16_t counters[2048];  // One per APID
} spp_seq_manager_t;

// Initialize sequence manager (all counters to 0)
void spp_seq_init(spp_seq_manager_t *mgr);

// Get next sequence count for APID (auto-increments, wraps at 16383)
uint16_t spp_seq_next(spp_seq_manager_t *mgr, uint16_t apid);

// Reset sequence counter for APID
void spp_seq_reset(spp_seq_manager_t *mgr, uint16_t apid);

// Build a complete unsegmented TM packet with CRC
ssize_t spp_build_tm_packet(uint16_t apid, uint16_t seq_count,
                            const uint8_t *payload, size_t payload_len,
                            uint8_t *output, size_t output_size);

// Build a complete unsegmented TC packet with CRC
ssize_t spp_build_tc_packet(uint16_t apid, uint16_t seq_count,
                            const uint8_t *payload, size_t payload_len,
                            uint8_t *output, size_t output_size);

// Segment large data into multiple packets
// Returns number of packets generated
size_t spp_segment(uint16_t apid, spp_packet_type_t type,
                   const uint8_t *data, size_t data_len,
                   size_t max_packet_size,
                   spp_packet_t *packets, size_t max_packets);

#include "ccsds_spp.h"
#include <stdio.h>

int main(void) {
    // Housekeeping telemetry data
    uint8_t hk_data[] = {
        0x00, 0x1A,   // Battery voltage: 2.6V (scaled)
        0x01, 0x2C,   // Solar panel current: 300mA
        0xFF, 0xE2,   // Temperature: -30 (signed, 0.1°C units)
        0x00, 0x03    // Mode: SCIENCE (3)
    };

    // Build packet
    uint8_t packet_buf[256];
    spp_seq_manager_t seq;
    spp_seq_init(&seq);

    ssize_t pkt_size = spp_build_tm_packet(
        0x001,                          // APID: housekeeping
        spp_seq_next(&seq, 0x001),      // Next sequence number
        hk_data, sizeof(hk_data),       // Payload
        packet_buf, sizeof(packet_buf)  // Output buffer
    );

    if (pkt_size > 0) {
        printf("Packet built: %zd bytes\n", pkt_size);
        printf("  Header: %02X %02X %02X %02X %02X %02X\n",
               packet_buf[0], packet_buf[1], packet_buf[2],
               packet_buf[3], packet_buf[4], packet_buf[5]);
        // Ready to insert into TM Transfer Frame
    }

    // Decode it back
    spp_packet_t decoded;
    spp_decode(packet_buf, pkt_size, &decoded);
    printf("  APID: 0x%03X | Type: %s | Seq: %u | CRC: %s\n",
           decoded.header.apid,
           decoded.header.type == SPP_TYPE_TM ? "TM" : "TC",
           decoded.header.seq_count,
           decoded.crc_valid ? "VALID" : "INVALID");

    return 0;
}