ra8-firmware/c6__cam__net_8c_source.html

#include <stdint.h>

#include <string.h>


#include "c6_camera_server.h"

#include "nx_api.h"

#include "nx_ether_driver_c6.h"

#include "nxd_dhcp_client.h"

#include "ra8_attributes.h"

#include "ra8_c6link.h"

#include "ra8_err.h"

#include "tx_api.h"


static NX_PACKET_POOL s_pool;

alignas(4) static uint8_t s_pool_mem[k_c6_cam_net_pool_bytes];

static NX_IP s_ip;

alignas(8) static uint8_t s_ip_stack[k_c6_cam_net_ip_stack];

alignas(4) static uint8_t s_arp_cache[k_c6_cam_net_arp_bytes];

static NX_DHCP       s_dhcp;

static NX_TCP_SOCKET s_http_socket;

static CHAR          s_pool_name[]   = "c6_cam_pool";

static CHAR          s_ip_name[]     = "c6_cam_ip";

static CHAR          s_dhcp_name[]   = "c6_cam_dhcp";

static CHAR          s_socket_name[] = "c6_cam_http";


static const char s_page[] =

  "<!doctype html><html><head><meta charset=utf-8>"

  "<meta name=viewport content='width=device-width,initial-scale=1'>"

  "<title>EK-RA8D2 Camera</title><style>body{margin:0;background:#111;color:#eee;"

  "font:16px system-ui;display:grid;place-items:center;min-height:100vh}main{text-align:center}"

  "img{width:min(96vw,960px);height:auto;image-rendering:auto;border:1px solid #555}"

  "small{display:block;margin-top:.5rem;color:#aaa}audio{margin-top:1rem}</style></head><body><main>"

  "<h1>EK-RA8D2 / OV5640</h1><img id=stream src=/stream.mjpg alt='live camera'>"

  "<small>bounded multipart MJPEG stream with automatic reconnect</small>"

  "<audio controls src=/audio.wav></audio>"

  "<small>latest rolling one-second onboard MIC1 recording</small>"

  "<script>const s=document.getElementById('stream');s.onerror=()=>{"

  "setTimeout(()=>{s.src='/stream.mjpg?t='+Date.now()},1000)}</script>"

  "</main></body></html>";


RA8_INTERNAL static UINT internal_c6_cam_net_create(void)

{

  UINT status = nx_packet_pool_create(&s_pool,

                                      s_pool_name,

                                      (ULONG)k_c6_cam_net_pkt_payload,

                                      (VOID*)s_pool_mem,

                                      (ULONG)sizeof(s_pool_mem));

  if (status != NX_SUCCESS) {

    return status;

  }

  status = nx_ip_create(&s_ip,

                        s_ip_name,

                        IP_ADDRESS(0, 0, 0, 0),

                        IP_ADDRESS(0, 0, 0, 0),

                        &s_pool,

                        nx_ether_driver_c6,

                        (VOID*)s_ip_stack,

                        (ULONG)sizeof(s_ip_stack),

                        (UINT)k_c6_cam_net_ip_prio);

  if (status != NX_SUCCESS) {

    return status;

  }

  status = nx_arp_enable(&s_ip, (VOID*)s_arp_cache, (ULONG)sizeof(s_arp_cache));

  if (status != NX_SUCCESS) {

    return status;

  }

  status = nx_udp_enable(&s_ip);

  if (status != NX_SUCCESS) {

    return status;

  }

  status = nx_tcp_enable(&s_ip);

  if (status != NX_SUCCESS) {

    return status;

  }

  return nx_icmp_enable(&s_ip);

}


ra8_err_t c6_cam_net_up(ra8_c6link_t* link, const ra8_c6link_mac_t* mac, c6_cam_lease_t* out)

{

  if ((link == nullptr) || (mac == nullptr) || (out == nullptr)) {

    return k_ra8_err_null_ptr;

  }

  *out = (c6_cam_lease_t){};

  nx_ether_driver_c6_bind(link);

  nx_ether_driver_c6_set_mac(mac->octet);

  nx_system_initialize();

  if (internal_c6_cam_net_create() != NX_SUCCESS) {

    return k_ra8_err_not_initialized;

  }

  UINT status = nx_dhcp_create(&s_dhcp, &s_ip, s_dhcp_name);

  if (status == NX_SUCCESS) {

    status = nx_dhcp_start(&s_dhcp);

  }

  ULONG actual = 0U;

  if (status == NX_SUCCESS) {

    status = nx_ip_status_check(&s_ip,

                                (ULONG)NX_IP_ADDRESS_RESOLVED,

                                &actual,

                                (ULONG)k_c6_cam_dhcp_wait_ms);

  }

  if (status != NX_SUCCESS) {

    return k_ra8_err_timeout;

  }

  ULONG ip      = 0U;

  ULONG mask    = 0U;

  ULONG gateway = 0U;

  ULONG server  = 0U;

  (void)nx_ip_address_get(&s_ip, &ip, &mask);

  (void)nx_ip_gateway_address_get(&s_ip, &gateway);

  (void)nx_dhcp_server_address_get(&s_dhcp, &server);

  out->ip          = (uint32_t)ip;

  out->mask        = (uint32_t)mask;

  out->gateway     = (uint32_t)gateway;

  out->dhcp_server = (uint32_t)server;

  out->bound       = (ip != 0U);

  return out->bound ? k_ra8_ok : k_ra8_err_timeout;

}


RA8_INTERNAL static UINT internal_c6_cam_http_send(const void* data, uint32_t bytes)

{

  const uint8_t* cursor    = (const uint8_t*)data;

  uint32_t       remaining = bytes;

  while (remaining != 0U) {

    const uint32_t chunk =

      (remaining > (uint32_t)k_c6_cam_http_chunk) ? (uint32_t)k_c6_cam_http_chunk : remaining;

    NX_PACKET* packet = NX_NULL;

    UINT       status = nx_packet_allocate(&s_pool, &packet, NX_TCP_PACKET, NX_WAIT_FOREVER);

    if (status != NX_SUCCESS) {

      return status;

    }

    status = nx_packet_data_append(packet,

                                   (VOID*)(uintptr_t)cursor,

                                   (ULONG)chunk,

                                   &s_pool,

                                   NX_WAIT_FOREVER);

    if (status != NX_SUCCESS) {

      (void)nx_packet_release(packet);

      return status;

    }

    status = nx_tcp_socket_send(&s_http_socket, packet, NX_WAIT_FOREVER);

    if (status != NX_SUCCESS) {

      (void)nx_packet_release(packet);

      return status;

    }

    cursor += chunk;

    remaining -= chunk;

  }

  return NX_SUCCESS;

}


RA8_INTERNAL static uint32_t


internal_c6_cam_append(char* out, uint32_t at, uint32_t cap, const char* text)

{

  while ((at < cap) && (*text != '\0')) {

    out[at++] = *text++;

  }

  return at;

}


typedef enum : uint32_t {

  k_c6_cam_net_decimal_digits = 10U,

  k_c6_cam_http_get_min       = 5U,

} c6_cam_net_format_t;


RA8_INTERNAL static uint32_t


internal_c6_cam_append_u32(char* out, uint32_t at, uint32_t cap, uint32_t value)

{

  char     reverse[k_c6_cam_net_decimal_digits] = {};

  uint32_t count                                = 0U;

  do {

    reverse[count++] = (char)('0' + (value % (uint32_t)k_c6_cam_net_decimal_digits));

    value /= (uint32_t)k_c6_cam_net_decimal_digits;

  } while ((value != 0U) && (count < (uint32_t)k_c6_cam_net_decimal_digits));

  while ((count != 0U) && (at < cap)) {

    out[at++] = reverse[--count];

  }

  return at;

}


RA8_INTERNAL static UINT internal_c6_cam_http_response(const char*                  type,

                                                       const void*                  body,

                                                       uint32_t                     body_bytes,

                                                       const c6_cam_frame_timing_t* timing,

                                                       uint32_t                     timestamp_ms)

{

  char     header[320] = {};

  uint32_t length =

    internal_c6_cam_append(header, 0U, sizeof(header), "HTTP/1.1 200 OK\r\nContent-Type: ");

  length = internal_c6_cam_append(header, length, sizeof(header), type);

  if (timing != nullptr) {

    length =

      internal_c6_cam_append(header, length, sizeof(header), "\r\nServer-Timing: capture;dur=");

    length = internal_c6_cam_append_u32(header, length, sizeof(header), timing->capture_ms);

    length = internal_c6_cam_append(header, length, sizeof(header), ", convert;dur=");

    length = internal_c6_cam_append_u32(header, length, sizeof(header), timing->convert_ms);

    length = internal_c6_cam_append(header, length, sizeof(header), ", encode;dur=");

    length = internal_c6_cam_append_u32(header, length, sizeof(header), timing->encode_ms);

  }

  if (timestamp_ms != 0U) {

    length = internal_c6_cam_append(header, length, sizeof(header), "\r\nX-RA8-Timestamp-Ms: ");

    length = internal_c6_cam_append_u32(header, length, sizeof(header), timestamp_ms);

  }

  length = internal_c6_cam_append(header, length, sizeof(header), "\r\nContent-Length: ");

  length = internal_c6_cam_append_u32(header, length, sizeof(header), body_bytes);

  length =

    internal_c6_cam_append(header,

                           length,

                           sizeof(header),

                           "\r\nCache-Control: no-store, no-cache\r\nConnection: close\r\n\r\n");

  UINT status = internal_c6_cam_http_send(header, length);

  if (status == NX_SUCCESS) {

    status = internal_c6_cam_http_send(body, body_bytes);

  }

  return status;

}


RA8_INTERNAL static UINT internal_c6_cam_http_stream(void)

{

  static const char stream_header[] = "HTTP/1.1 200 OK\r\n"

                                      "Content-Type: multipart/x-mixed-replace; boundary=frame\r\n"

                                      "Cache-Control: no-store, no-cache\r\n"

                                      "Connection: close\r\n\r\n";

  UINT status = internal_c6_cam_http_send(stream_header, (uint32_t)(sizeof(stream_header) - 1U));

  for (uint32_t frame_index = 0U;

       (frame_index < (uint32_t)k_c6_cam_stream_frames) && (status == NX_SUCCESS);

       frame_index++) {

    const uint8_t*        jpeg       = nullptr;

    uint32_t              jpeg_bytes = 0U;

    c6_cam_frame_timing_t timing     = {};

    const ra8_err_t       err        = c6_cam_camera_capture_jpeg(&jpeg, &jpeg_bytes, &timing);

    if (err != k_ra8_ok) {

      c6_cam_camera_report_last_error();

      return NX_NOT_SUCCESSFUL;

    }

    char     part_header[128] = {};

    uint32_t length =

      internal_c6_cam_append(part_header,

                             0U,

                             sizeof(part_header),

                             "--frame\r\nContent-Type: image/jpeg\r\nContent-Length: ");

    length = internal_c6_cam_append_u32(part_header, length, sizeof(part_header), jpeg_bytes);

    length = internal_c6_cam_append(part_header, length, sizeof(part_header), "\r\n\r\n");

    status = internal_c6_cam_http_send(part_header, length);

    if (status == NX_SUCCESS) {

      status = internal_c6_cam_http_send(jpeg, jpeg_bytes);

    }

    if (status == NX_SUCCESS) {

      static const char part_tail[] = "\r\n";

      status = internal_c6_cam_http_send(part_tail, (uint32_t)(sizeof(part_tail) - 1U));

    }

    if (status == NX_SUCCESS) {

      c6_cam_puts("c6_cam: stream jpeg_bytes=");

      c6_cam_put_u32(jpeg_bytes);

      c6_cam_puts(" capture_ms=");

      c6_cam_put_u32(timing.capture_ms);

      c6_cam_puts(" convert_ms=");

      c6_cam_put_u32(timing.convert_ms);

      c6_cam_puts(" encode_ms=");

      c6_cam_put_u32(timing.encode_ms);

      c6_cam_puts("\r\n");

    }

  }

  return status;

}


RA8_INTERNAL static bool


internal_c6_cam_request_is(const char* request, uint32_t bytes, const char* path)

{

  if ((bytes < (uint32_t)k_c6_cam_http_get_min) || (memcmp(request, "GET ", 4U) != 0)) {

    return false;

  }

  uint32_t index      = 4U;

  uint32_t path_index = 0U;

  while ((index < bytes) && (path[path_index] != '\0') && (request[index] == path[path_index])) {

    index++;

    path_index++;

  }

  if (path[path_index] != '\0') {

    return false;

  }

  return (index < bytes) && ((request[index] == ' ') || (request[index] == '?'));

}


RA8_INTERNAL static void internal_c6_cam_http_frame(void)

{

  const uint8_t*        jpeg       = nullptr;

  uint32_t              jpeg_bytes = 0U;

  c6_cam_frame_timing_t timing     = {};

  const ra8_err_t       err        = c6_cam_camera_capture_jpeg(&jpeg, &jpeg_bytes, &timing);

  if (err == k_ra8_ok) {

    (void)

      internal_c6_cam_http_response("image/jpeg", jpeg, jpeg_bytes, &timing, timing.timestamp_ms);

    c6_cam_puts("c6_cam: frame jpeg_bytes=");

    c6_cam_put_u32(jpeg_bytes);

    c6_cam_puts(" capture_ms=");

    c6_cam_put_u32(timing.capture_ms);

    c6_cam_puts(" convert_ms=");

    c6_cam_put_u32(timing.convert_ms);

    c6_cam_puts(" encode_ms=");

    c6_cam_put_u32(timing.encode_ms);

    c6_cam_puts("\r\n");

    return;

  }

  static const char failed[] = "camera capture failed\n";

  (void)internal_c6_cam_http_response("text/plain",

                                      failed,

                                      (uint32_t)(sizeof(failed) - 1U),

                                      nullptr,

                                      0U);

  c6_cam_puts("c6_cam: frame FAIL err=");

  c6_cam_puts(ra8_err_to_str(err));

  c6_cam_camera_report_last_error();

  c6_cam_puts("\r\n");

}


RA8_INTERNAL static void internal_c6_cam_http_audio(void)

{

  const uint8_t*  wav          = nullptr;

  uint32_t        wav_bytes    = 0U;

  uint32_t        timestamp_ms = 0U;

  const ra8_err_t err          = c6_cam_audio_snapshot_wav(&wav, &wav_bytes, &timestamp_ms);

  if (err == k_ra8_ok) {

    (void)internal_c6_cam_http_response("audio/wav", wav, wav_bytes, nullptr, timestamp_ms);

    c6_cam_puts("c6_cam: audio wav_bytes=");

    c6_cam_put_u32(wav_bytes);

    c6_cam_puts(" timestamp_ms=");

    c6_cam_put_u32(timestamp_ms);

    c6_cam_puts("\r\n");

    return;

  }

  static const char unavailable[] = "audio capture not ready\n";

  (void)internal_c6_cam_http_response("text/plain",

                                      unavailable,

                                      (uint32_t)(sizeof(unavailable) - 1U),

                                      nullptr,

                                      0U);

}


RA8_INTERNAL static void internal_c6_cam_http_dispatch(const char* request, uint32_t bytes)

{

  if (internal_c6_cam_request_is(request, bytes, "/stream.mjpg")) {

    (void)internal_c6_cam_http_stream();

  } else if (internal_c6_cam_request_is(request, bytes, "/frame.jpg")) {

    internal_c6_cam_http_frame();

  } else if (internal_c6_cam_request_is(request, bytes, "/audio.wav")) {

    internal_c6_cam_http_audio();

  } else if (internal_c6_cam_request_is(request, bytes, "/health")) {

    static const char healthy[] = "PASS c6 camera livestream audio=PASS camera=PASS\n";

    (void)internal_c6_cam_http_response("text/plain",

                                        healthy,

                                        (uint32_t)(sizeof(healthy) - 1U),

                                        nullptr,

                                        0U);

  } else {

    (void)internal_c6_cam_http_response("text/html; charset=utf-8",

                                        s_page,

                                        (uint32_t)(sizeof(s_page) - 1U),

                                        nullptr,

                                        0U);

  }

}


RA8_INTERNAL static void internal_c6_cam_http_handle(void)

{

  NX_PACKET* request_packet = NX_NULL;

  if (nx_tcp_socket_receive(&s_http_socket, &request_packet, NX_WAIT_FOREVER) != NX_SUCCESS) {

    return;

  }

  ULONG packet_bytes = 0U;

  (void)nx_packet_length_get(request_packet, &packet_bytes);

  uint32_t request_bytes                 = (packet_bytes > (ULONG)k_c6_cam_request_max)

                                             ? (uint32_t)k_c6_cam_request_max

                                             : (uint32_t)packet_bytes;

  char     request[k_c6_cam_request_max] = {};

  ULONG    copied                        = 0U;

  (void)nx_packet_data_extract_offset(request_packet, 0U, request, (ULONG)request_bytes, &copied);

  (void)nx_packet_release(request_packet);

  internal_c6_cam_http_dispatch(request, (uint32_t)copied);

}


void c6_cam_http_serve(void)

{

  UINT status = nx_tcp_socket_create(&s_ip,

                                     &s_http_socket,

                                     s_socket_name,

                                     NX_IP_NORMAL,

                                     NX_FRAGMENT_OKAY,

                                     NX_IP_TIME_TO_LIVE,

                                     (ULONG)k_c6_cam_tcp_window,

                                     NX_NULL,

                                     NX_NULL);

  if (status == NX_SUCCESS) {

    status = nx_tcp_server_socket_listen(&s_ip,

                                         (UINT)k_c6_cam_http_port,

                                         &s_http_socket,

                                         (UINT)k_c6_cam_listen_backlog,

                                         NX_NULL);

  }

  if (status != NX_SUCCESS) {

    c6_cam_puts("c6_cam: FAIL HTTP socket setup\r\n");

    while (true) {

      tx_thread_sleep(NX_IP_PERIODIC_RATE);

    }

  }

  c6_cam_puts("c6_cam: PASS HTTP camera server listening\r\n");

  while (true) {

    if (nx_tcp_server_socket_accept(&s_http_socket, NX_WAIT_FOREVER) == NX_SUCCESS) {

      internal_c6_cam_http_handle();

      (void)nx_tcp_socket_disconnect(&s_http_socket, NX_WAIT_FOREVER);

      (void)nx_tcp_server_socket_unaccept(&s_http_socket);

    }

    (void)nx_tcp_server_socket_relisten(&s_ip, (UINT)k_c6_cam_http_port, &s_http_socket);

  }

}


s_dhcp_name
static CHAR s_dhcp_name[]
Definition c6_cam_net.c:39

internal_c6_cam_http_send
static UINT internal_c6_cam_http_send(const void *data, uint32_t bytes)
Send an exact byte span over the accepted HTTP socket.
Definition c6_cam_net.c:163

c6_cam_net_format_t
c6_cam_net_format_t
Decimal formatting and minimum HTTP request sizes.
Definition c6_cam_net.c:221

k_c6_cam_http_get_min
@ k_c6_cam_http_get_min
Minimum bytes in an HTTP GET prefix.
Definition c6_cam_net.c:223

k_c6_cam_net_decimal_digits
@ k_c6_cam_net_decimal_digits
Decimal digits in a 32-bit integer.
Definition c6_cam_net.c:222

c6_cam_http_serve
void c6_cam_http_serve(void)
Serve the browser UI and fresh JPEG frames forever.
Definition c6_cam_net.c:550

internal_c6_cam_http_dispatch
static void internal_c6_cam_http_dispatch(const char *request, uint32_t bytes)
Dispatch a bounded HTTP request to one route handler.
Definition c6_cam_net.c:498

s_pool_mem
static uint8_t s_pool_mem[k_c6_cam_net_pool_bytes]
Definition c6_cam_net.c:31

s_pool_name
static CHAR s_pool_name[]
Definition c6_cam_net.c:37

internal_c6_cam_http_audio
static void internal_c6_cam_http_audio(void)
Snapshot and serve the current audio window.
Definition c6_cam_net.c:462

s_page
static const char s_page[]
Definition c6_cam_net.c:42

internal_c6_cam_http_handle
static void internal_c6_cam_http_handle(void)
Receive and dispatch one HTTP request.
Definition c6_cam_net.c:532

internal_c6_cam_http_frame
static void internal_c6_cam_http_frame(void)
Capture and serve one JPEG still response.
Definition c6_cam_net.c:419

s_http_socket
static NX_TCP_SOCKET s_http_socket
Definition c6_cam_net.c:36

internal_c6_cam_request_is
static bool internal_c6_cam_request_is(const char *request, uint32_t bytes, const char *path)
Match a bounded HTTP GET request path.
Definition c6_cam_net.c:391

internal_c6_cam_http_response
static UINT internal_c6_cam_http_response(const char *type, const void *body, uint32_t body_bytes, const c6_cam_frame_timing_t *timing, uint32_t timestamp_ms)
Send one complete close-delimited HTTP response.
Definition c6_cam_net.c:275

internal_c6_cam_http_stream
static UINT internal_c6_cam_http_stream(void)
Serve a bounded multipart MJPEG sequence.
Definition c6_cam_net.c:325

s_dhcp
static NX_DHCP s_dhcp
Definition c6_cam_net.c:35

c6_cam_net_up
ra8_err_t c6_cam_net_up(ra8_c6link_t *link, const ra8_c6link_mac_t *mac, c6_cam_lease_t *out)
Bind NetX to an associated raw C6 link and obtain a DHCP lease.
Definition c6_cam_net.c:107

s_socket_name
static CHAR s_socket_name[]
Definition c6_cam_net.c:40

s_ip_name
static CHAR s_ip_name[]
Definition c6_cam_net.c:38

internal_c6_cam_net_create
static UINT internal_c6_cam_net_create(void)
Create the static NetX packet pool and IP instance.
Definition c6_cam_net.c:70

internal_c6_cam_append_u32
static uint32_t internal_c6_cam_append_u32(char *out, uint32_t at, uint32_t cap, uint32_t value)
Append an unsigned decimal value to a fixed buffer.
Definition c6_cam_net.c:243

internal_c6_cam_append
static uint32_t internal_c6_cam_append(char *out, uint32_t at, uint32_t cap, const char *text)
Append bounded text to a fixed HTTP header buffer.
Definition c6_cam_net.c:212

c6_camera_server.h
Shared contracts for ESP32-C6 browser camera servers.

c6_cam_put_u32
void c6_cam_put_u32(uint32_t value)
Write one unsigned decimal value to SCI8.
Definition c6_cam_console.c:44

c6_cam_audio_snapshot_wav
ra8_err_t c6_cam_audio_snapshot_wav(const uint8_t **out_wav, uint32_t *out_bytes, uint32_t *out_timestamp_ms)
Snapshot the rolling microphone ring as mono PCM-S16LE WAV.
Definition c6_cam_audio.c:273

k_c6_cam_tcp_window
@ k_c6_cam_tcp_window
HTTP socket receive window.
Definition c6_camera_server.h:37

k_c6_cam_net_ip_stack
@ k_c6_cam_net_ip_stack
NetX IP thread stack bytes.
Definition c6_camera_server.h:42

k_c6_cam_request_max
@ k_c6_cam_request_max
Maximum parsed request bytes.
Definition c6_camera_server.h:36

k_c6_cam_net_pool_bytes
@ k_c6_cam_net_pool_bytes
NetX packet pool bytes.
Definition c6_camera_server.h:41

k_c6_cam_dhcp_wait_ms
@ k_c6_cam_dhcp_wait_ms
DHCP lease timeout.
Definition c6_camera_server.h:30

k_c6_cam_net_arp_bytes
@ k_c6_cam_net_arp_bytes
NetX ARP cache bytes.
Definition c6_camera_server.h:43

k_c6_cam_net_pkt_payload
@ k_c6_cam_net_pkt_payload
NetX packet payload bytes.
Definition c6_camera_server.h:40

k_c6_cam_net_ip_prio
@ k_c6_cam_net_ip_prio
NetX IP thread priority.
Definition c6_camera_server.h:44

k_c6_cam_listen_backlog
@ k_c6_cam_listen_backlog
Single-client listen backlog.
Definition c6_camera_server.h:38

k_c6_cam_http_chunk
@ k_c6_cam_http_chunk
Maximum HTTP send chunk.
Definition c6_camera_server.h:35

k_c6_cam_stream_frames
@ k_c6_cam_stream_frames
Frames served before client reconnect.
Definition c6_camera_server.h:39

k_c6_cam_http_port
@ k_c6_cam_http_port
Browser server TCP port.
Definition c6_camera_server.h:34

c6_cam_camera_capture_jpeg
ra8_err_t c6_cam_camera_capture_jpeg(const uint8_t **out_jpeg, uint32_t *out_bytes, c6_cam_frame_timing_t *out_timing)
Definition c6_cam_camera.c:196

c6_cam_puts
void c6_cam_puts(const char *text)
Write a bounded NUL-terminated string to SCI8.
Definition c6_cam_console.c:32

c6_cam_camera_report_last_error
void c6_cam_camera_report_last_error(void)
Emit backend-specific diagnostics for the last capture failure.
Definition c6_cam_camera.c:239

s_ip_stack
static ULONG s_ip_stack[k_demo_ip_stack/sizeof(ULONG)]
Definition main.c:232

s_ip
static NX_IP s_ip
Definition main.c:229

s_arp_cache
static ULONG s_arp_cache[k_demo_arp_cache/sizeof(ULONG)]
Definition main.c:233

nx_ether_driver_c6.h
NetX Duo network driver shim that bridges onto the ESP32-C6 link.

nx_ether_driver_c6_bind
void nx_ether_driver_c6_bind(ra8_c6link_t *link)
Bind an open C6 link handle to the driver and arm its mutex.
Definition nx_ether_driver_c6.c:198

nx_ether_driver_c6
void nx_ether_driver_c6(NX_IP_DRIVER *driver_req)
NetX Duo link driver entry point for the ESP32-C6 Wi-Fi station.
Definition nx_ether_driver_c6.c:770

nx_ether_driver_c6_set_mac
void nx_ether_driver_c6_set_mac(const uint8_t mac[6])
Tell the driver the station MAC address to stamp on outgoing frames.
Definition nx_ether_driver_c6.c:189

ra8_attributes.h
Annotation-attribute framework macros for ra8-firmware.

RA8_INTERNAL
#define RA8_INTERNAL
Marker that a function is intended to be static (file-local).
Definition ra8_attributes.h:190

ra8_c6link.h
The single integration boundary between this firmware and the ESP32-C6.

ra8_c6link_mac_t
struct ra8_c6link_mac ra8_c6link_mac_t

ra8_c6link_t
struct ra8_c6link ra8_c6link_t

ra8_err.h
Error Code Definitions for ra8-firmware.

k_ra8_err_not_initialized
@ k_ra8_err_not_initialized
Module not initialized – _init() not yet called successfully.
Definition ra8_err.h:235

k_ra8_ok
@ k_ra8_ok
Success – operation completed with all postconditions satisfied.
Definition ra8_err.h:119

k_ra8_err_null_ptr
@ k_ra8_err_null_ptr
Pointer was NULL where a valid pointer was required.
Definition ra8_err.h:478

k_ra8_err_timeout
@ k_ra8_err_timeout
Operation exceeded its time budget.
Definition ra8_err.h:188

ra8_err_t
ra8_err_codes_t ra8_err_t
Canonical error-return type used by every ra8-firmware API.
Definition ra8_err.h:546

ra8_err_to_str
const char * ra8_err_to_str(ra8_err_t err)
Human-readable string for an error code.
Definition ra8_log.c:737

s_pool
static ra8_esp_hosted_pool_state_t s_pool
Singleton state of the memory and queue half.
Definition ra8_esp_hosted_rtos_pool.c:174

memcmp
int memcmp(const void *a, const void *b, size_t n)
Compare bytes in two memory areas.
Definition ra8_freestanding_mem.c:136

UINT
unsigned int UINT
ThreadX-compatible unsigned int (host stub).
Definition ra8_wdt_sup_tx_shim_internal.h:74

tx_thread_sleep
#define tx_thread_sleep
Definition ra8_wdt_sup_tx_shim_internal.h:53

CHAR
char CHAR
ThreadX-compatible CHAR (host stub).
Definition ra8_wdt_sup_tx_shim_internal.h:80

ULONG
unsigned long ULONG
ThreadX-compatible unsigned long (host stub).
Definition ra8_wdt_sup_tx_shim_internal.h:68

c6_cam_frame_timing_t
Per-frame pipeline latency exposed in HTTP Server-Timing headers.
Definition c6_camera_server.h:57

c6_cam_frame_timing_t::convert_ms
uint32_t convert_ms
Pixel conversion latency.
Definition c6_camera_server.h:60

c6_cam_frame_timing_t::timestamp_ms
uint32_t timestamp_ms
Capture-start monotonic timestamp.
Definition c6_camera_server.h:58

c6_cam_frame_timing_t::capture_ms
uint32_t capture_ms
Camera capture latency.
Definition c6_camera_server.h:59

c6_cam_frame_timing_t::encode_ms
uint32_t encode_ms
Codec latency.
Definition c6_camera_server.h:61

c6_cam_lease_t
DHCP lease returned by the raw, bench-validated C6/NetX path.
Definition c6_camera_server.h:48

c6_cam_lease_t::bound
bool bound
True after a lease is bound.
Definition c6_camera_server.h:53

c6_cam_lease_t::dhcp_server
uint32_t dhcp_server
DHCP server IPv4 address.
Definition c6_camera_server.h:52

c6_cam_lease_t::ip
uint32_t ip
Assigned IPv4 address.
Definition c6_camera_server.h:49

c6_cam_lease_t::gateway
uint32_t gateway
Assigned IPv4 default gateway.
Definition c6_camera_server.h:51

c6_cam_lease_t::mask
uint32_t mask
Assigned IPv4 network mask.
Definition c6_camera_server.h:50

ra8_c6link_mac::octet
uint8_t octet[k_ra8_c6link_mac_bytes]
Address octets, first on the wire first.
Definition ra8_c6link.h:199