Time-Triggered Ethernet (AS6802/TTE)¶

// Schedule table entry
typedef struct {
    uint32_t cycle_offset_ns;    // Offset within integration cycle
    uint16_t ct_id;              // Critical Traffic ID
    uint8_t  port;               // Egress port
    uint16_t frame_size;         // Expected frame size
    uint8_t  period_multiple;    // Dispatch period = N × integration cycle
} tte_schedule_entry_t;

#include "tte.h"

typedef enum {
    TTE_TRAFFIC_TT = 0,     // Time-Triggered
    TTE_TRAFFIC_RC = 1,     // Rate-Constrained
    TTE_TRAFFIC_BE = 2      // Best-Effort
} tte_traffic_class_t;

typedef enum {
    TTE_SYNC_UNSYNC = 0,
    TTE_SYNC_INTEGRATING = 1,
    TTE_SYNC_SYNC = 2,
    TTE_SYNC_STABLE = 3
} tte_sync_state_t;

typedef struct {
    uint8_t  dst_mac[6];
    uint8_t  src_mac[6];
    uint16_t ethertype;          // 0x891D for TTE
    uint32_t integration_cycle;
    uint32_t membership_new;
    uint16_t sync_priority;
    uint8_t  sync_domain;
    uint8_t  pcf_type;
    int64_t  transparent_clock;  // Nanoseconds
    int64_t  cluster_time;       // Nanoseconds
} tte_pcf_t;

typedef struct {
    uint32_t ct_id;              // Critical Traffic identifier
    uint32_t cycle_offset_ns;   // Dispatch offset
    uint8_t  period_multiple;   // Period = N × integration cycle
    uint16_t max_frame_size;
    uint8_t  egress_port;
} tte_schedule_entry_t;

typedef struct {
    tte_schedule_entry_t *entries;
    size_t                entry_count;
    uint32_t              integration_cycle_ns;
} tte_schedule_t;

// Initialize TTE switch context
void tte_switch_init(tte_switch_t *sw, uint8_t num_ports,
                     const tte_schedule_t *schedule);

// Process incoming frame; returns traffic class and action
tte_traffic_class_t tte_switch_classify(const tte_switch_t *sw,
                                         const uint8_t *frame,
                                         size_t frame_len);

// Forward TT frame according to schedule (called by timer)
int tte_switch_dispatch_tt(tte_switch_t *sw, uint32_t current_time_ns);

// Forward RC frame (checks BAG compliance)
int tte_switch_forward_rc(tte_switch_t *sw, const uint8_t *frame,
                          size_t frame_len, uint8_t ingress_port);

// Update transparent clock field in PCF
void tte_switch_update_transparent_clock(tte_pcf_t *pcf,
                                          uint32_t residence_ns);

// Initialize TTE end system
void tte_es_init(tte_end_system_t *es, const tte_schedule_t *schedule);

// Clock synchronization: process received IN_FRAME
void tte_es_process_pcf(tte_end_system_t *es, const tte_pcf_t *pcf);

// Get current sync state
tte_sync_state_t tte_es_get_sync_state(const tte_end_system_t *es);

// Get synchronized network time
int64_t tte_es_get_time(const tte_end_system_t *es);

// Send TT frame (must be called at scheduled offset)
int tte_es_send_tt(tte_end_system_t *es, uint32_t ct_id,
                   const uint8_t *payload, size_t len);

// Send RC frame (BAG-policed)
int tte_es_send_rc(tte_end_system_t *es, uint16_t vl_id,
                   const uint8_t *payload, size_t len);

// Initialize compression master (runs on switch)
void tte_cm_init(tte_compression_master_t *cm, uint8_t num_sync_masters,
                 uint32_t integration_cycle_ns);

// Feed incoming CS_REQUEST; returns true when compression complete
bool tte_cm_process_cs_request(tte_compression_master_t *cm,
                               uint8_t sender_id, int64_t timestamp);

// Get compressed timestamp (median of received CS_REQUESTs)
int64_t tte_cm_get_compressed_time(const tte_compression_master_t *cm);

// Generate IN_FRAME for broadcast
void tte_cm_generate_in_frame(tte_compression_master_t *cm, tte_pcf_t *pcf);