File syn_router.h¶

FileList > net > syn_router.h

Packet router — addressed message dispatch. More...

#include "../common/syn_defs.h"
#include "../port/syn_port_system.h"
#include "syn_transport.h"
#include <stdbool.h>
#include <stdint.h>

Classes¶

Type	Name
struct	SYN_Packet Router packet — wire format header + payload buffer.
struct	SYN_PendingAck Pending ACK entry for reliable delivery tracking.
struct	SYN_Router Router instance — node ID, transport, handler table, ACK tracking.
struct	SYN_RouterHandler Handler registration entry — message type + callback.

Public Types¶

Type	Name
typedef void(*	SYN_RouterHandlerFn Packet handler callback.

Public Functions¶

Type	Name
void	syn_router_enable_ack (SYN_Router * r, SYN_PendingAck * pending, uint8_t cap, uint16_t timeout_ms, uint8_t max_retries) Enable reliable delivery (ACK/retry).
void	syn_router_init (SYN_Router * r, uint8_t node_id, SYN_Transport * transport, SYN_RouterHandler * handlers, uint8_t handler_cap) Initialize packet router.
void	syn_router_poll (SYN_Router * r) Poll for incoming packets and dispatch handlers.
bool	syn_router_register (SYN_Router * r, uint8_t type, SYN_RouterHandlerFn handler, void * ctx) Register a handler for a message type.
bool	syn_router_send (SYN_Router * r, uint8_t dst, uint8_t type, const uint8_t * data, uint8_t len, bool reliable) Send a message.

Macros¶

Type	Name
define	SYN_MSG_ACK `0x01`
define	SYN_MSG_DISCOVER `0x02`
define	SYN_MSG_HEARTBEAT `0x00`
define	SYN_PKT_FLAG_ACK_REQ `0x01`
define	SYN_PKT_FLAG_IS_ACK `0x02`
define	SYN_ROUTER_HEADER_SIZE `6`
define	SYN_ROUTER_MAX_PAYLOAD `64` Maximum router payload bytes.
define	SYN_ROUTER_MAX_PENDING `4` Maximum pending ACK entries.

Detailed Description¶

Routes packets between nodes over any SYN_Transport. Each node has an ID (0-254, 0xFF = broadcast). Messages have a type + payload. Handlers are registered per message type.

Supports optional reliable delivery (ACK/retry) per-send.

Usage:

static SYN_RouterHandler handlers[8];
static SYN_Router router;

syn_router_init(&router, 0x01, &transport,
                  handlers, SYN_ARRAY_SIZE(handlers));

syn_router_register(&router, MSG_SENSOR_DATA, on_sensor, NULL);

// Send
uint8_t payload[] = {0x42, 0x00};
syn_router_send(&router, 0x02, MSG_SENSOR_DATA,
                  payload, sizeof(payload), false);

// In main loop:
syn_router_poll(&router);

Public Types Documentation¶

typedef SYN_RouterHandlerFn¶

Packet handler callback.

typedef void(* SYN_RouterHandlerFn) (const SYN_Packet *pkt, void *ctx);

Parameters:

pkt Received packet.
ctx User context.

Public Functions Documentation¶

function syn_router_enable_ack¶

Enable reliable delivery (ACK/retry).

void syn_router_enable_ack (
    SYN_Router * r,
    SYN_PendingAck * pending,
    uint8_t cap,
    uint16_t timeout_ms,
    uint8_t max_retries
)

Parameters:

r Router.
pending Caller-owned pending ACK array.
cap Array capacity.
timeout_ms ACK timeout per attempt.
max_retries Max retransmissions before giving up.

function syn_router_init¶

Initialize packet router.

void syn_router_init (
    SYN_Router * r,
    uint8_t node_id,
    SYN_Transport * transport,
    SYN_RouterHandler * handlers,
    uint8_t handler_cap
)

Parameters:

r Router instance.
node_id This node's ID (0-254).
transport Transport to send/receive over.
handlers Caller-owned handler array.
handler_cap Array capacity.

function syn_router_poll¶

Poll for incoming packets and dispatch handlers.

void syn_router_poll (
    SYN_Router * r
)

Also checks for ACK timeouts and retransmits if needed. Call from your main loop.

Parameters:

r Router.

function syn_router_register¶

Register a handler for a message type.

bool syn_router_register (
    SYN_Router * r,
    uint8_t type,
    SYN_RouterHandlerFn handler,
    void * ctx
)

Parameters:

r Router.
type Message type to handle.
handler Handler function.
ctx User context.

Returns:

true if registered, false if handler table is full.

function syn_router_send¶

Send a message.

bool syn_router_send (
    SYN_Router * r,
    uint8_t dst,
    uint8_t type,
    const uint8_t * data,
    uint8_t len,
    bool reliable
)

Parameters:

r Router.
dst Destination node ID (0xFF = broadcast).
type Message type.
data Payload.
len Payload length.
reliable If true and ACK is enabled, wait for ACK with retry.

Returns:

true if sent (or queued for retry).

Macro Definition Documentation¶

define SYN_MSG_ACK¶

#define SYN_MSG_ACK `0x01`

Acknowledgment

define SYN_MSG_DISCOVER¶

#define SYN_MSG_DISCOVER `0x02`

Node discovery

define SYN_MSG_HEARTBEAT¶

#define SYN_MSG_HEARTBEAT `0x00`

Keepalive ping

define SYN_PKT_FLAG_ACK_REQ¶

#define SYN_PKT_FLAG_ACK_REQ `0x01`

Sender wants an ACK

define SYN_PKT_FLAG_IS_ACK¶

#define SYN_PKT_FLAG_IS_ACK `0x02`

This packet is an ACK

define SYN_ROUTER_HEADER_SIZE¶

#define SYN_ROUTER_HEADER_SIZE `6`

Wire format overhead: src(1) + dst(1) + type(1) + seq(1) + flags(1) + len(1) = 6 bytes

define SYN_ROUTER_MAX_PAYLOAD¶

Maximum router payload bytes.

#define SYN_ROUTER_MAX_PAYLOAD `64`

define SYN_ROUTER_MAX_PENDING¶

Maximum pending ACK entries.

#define SYN_ROUTER_MAX_PENDING `4`

The documentation for this class was generated from the following file src/syntropic/net/syn_router.h