main.c

Go to the documentation of this file.

 
#include <stdint.h>
 
#include "nx_ether_driver_c6.h"
#include "ra8_board_ek_ra8d2.h"
#include "ra8_boot_entry.h"
#include "ra8_c6link.h"
#include "ra8_cgc.h"
#include "ra8_err.h"
#include "ra8_esp_hosted_c6link.h"
#include "ra8_esp_hosted_port.h"
#include "ra8_isr.h"
#include "ra8_mstp.h"
#include "ra8_net_provision.h"
#include "ra8_time.h"
#include "ra8_wifi.h"
#include "ra8_wifi_c6link.h"
#include "tx_api.h"
#include "wifi_hal_join.h"

static uint32_t s_cpuclk_hz;
static uint32_t s_pclka_hz;
static ra8_err_t s_init_err = k_ra8_err_not_initialized;
static TX_THREAD s_worker;
static CHAR s_worker_name[] = "wifi_hal_join";
static UCHAR s_worker_stack[k_wifi_hal_worker_stack];
static uint8_t s_arena[k_wifi_hal_arena_bytes];
static ra8_c6link_t s_link;
static ra8_wifi_c6link_t s_c6;
static ra8_wifi_t s_wifi;
static const ra8_net_provision_uart_t s_provision_uart = {
  .write   = ra8_board_uart_console_write,
  .read    = ra8_board_uart_console_read,
  .wait_ms = ra8_delay_ms,
};

static void wifi_hal_panic_halt(void)
{
  while (true) {
    __asm volatile("wfi");
  }
}

static void wifi_hal_setup_or_halt(void)
{
  if (ra8_cgc_init() != k_ra8_ok) {
    wifi_hal_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &s_cpuclk_hz) != k_ra8_ok) {
    wifi_hal_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_pclka, &s_pclka_hz) != k_ra8_ok) {
    wifi_hal_panic_halt();
  }
  if (ra8_mstp_init() != k_ra8_ok) {
    wifi_hal_panic_halt();
  }
  if (ra8_time_init(s_cpuclk_hz) != k_ra8_ok) {
    wifi_hal_panic_halt();
  }
  if (ra8_board_uart_console_init((uint32_t)k_wifi_hal_uart_baud) != k_ra8_ok) {
    wifi_hal_panic_halt();
  }
}

static ra8_err_t wifi_hal_make_cfg(ra8_wifi_cfg_t* out)
{
  ra8_wifi_c6link_cfg_t bcfg = {};
  bcfg.link                  = &s_link;
  bcfg.arena                 = s_arena;
  bcfg.arena_bytes           = (uint32_t)sizeof(s_arena);
  bcfg.rx_cb                 = nx_ether_driver_c6_rx;
  const ra8_err_t bound      = ra8_esp_hosted_c6link_bind(&bcfg.transport);
  if (bound != k_ra8_ok) {
    return bound;
  }
  const ra8_err_t wired = ra8_wifi_c6link_setup(&s_c6, &bcfg, out);
  if (wired != k_ra8_ok) {
    return wired;
  }
  out->ip_bind = wifi_hal_ip_bind;
  out->ip_ctx  = &s_link;
  return k_ra8_ok;
}

static void wifi_hal_print_lease(const ra8_wifi_lease_t* lease)
{
  wifi_hal_puts("wifi_hal: dhcp bound ip=");
  wifi_hal_put_ip(lease->ip);
  wifi_hal_puts(" mask=");
  wifi_hal_put_ip(lease->mask);
  wifi_hal_puts(" gw=");
  wifi_hal_put_ip(lease->gateway);
  wifi_hal_puts(" server=");
  wifi_hal_put_ip(lease->dhcp_server);
  wifi_hal_puts("\r\n");
}
 
static bool wifi_hal_report(const wifi_hal_result_t* res, bool joined);

static bool wifi_hal_run(const ra8_net_credentials_t* credentials)
{
  ra8_wifi_cfg_t  cfg  = {};
  const ra8_err_t made = wifi_hal_make_cfg(&cfg);
  if (made != k_ra8_ok) {
    wifi_hal_puts("wifi_hal: FAIL transport setup err=");
    wifi_hal_puts(ra8_err_to_str(made));
    wifi_hal_puts("\r\n");
    return false;
  }
 
  const wifi_hal_run_cfg_t rcfg = {
    .wifi_cfg    = &cfg,
    .wifi        = &s_wifi,
    .ssid        = credentials->ssid,
    .psk         = credentials->psk,
    .poll_budget = (uint32_t)k_wifi_hal_assoc_polls,
  };
  wifi_hal_result_t res    = {};
  const bool        joined = wifi_hal_join_run(&rcfg, &res);
  return wifi_hal_report(&res, joined);
}

static bool wifi_hal_report(const wifi_hal_result_t* res, bool joined)
{
  wifi_hal_puts("wifi_hal: init=");
  wifi_hal_puts(ra8_err_to_str(res->init_err));
  wifi_hal_puts("\r\n");
  if (!res->init_ok) {
    return false;
  }
 
  if (!res->associated) {
    wifi_hal_puts("wifi_hal: FAIL association did not complete connect=");
    wifi_hal_puts(ra8_err_to_str(res->connect_err));
    wifi_hal_puts("\r\n");
    return false;
  }
 
  wifi_hal_puts("wifi_hal: associated mac=");
  wifi_hal_put_mac(&res->mac);
  wifi_hal_puts(" chan=");
  wifi_hal_put_u32((uint32_t)res->ap.channel);
  wifi_hal_puts("\r\n");
  if (!res->ip_bound) {
    wifi_hal_puts("wifi_hal: FAIL dhcp did not bind err=");
    wifi_hal_puts(ra8_err_to_str(res->ip_err));
    wifi_hal_puts("\r\n");
    return false;
  }
  wifi_hal_print_lease(&res->lease);
  if (!joined) {
    wifi_hal_puts("wifi_hal: FAIL join_run failed with every stage reported ok\r\n");
  }
  return joined;
}

static void wifi_hal_heartbeat(bool passed)
{
  while (true) {
    wifi_hal_puts(passed ? "wifi_hal: alive PASS\r\n" : "wifi_hal: alive FAIL\r\n");
    tx_thread_sleep((ULONG)k_wifi_hal_heartbeat_ms);
  }
}

static void wifi_hal_worker_entry(ULONG thread_input)
{
  (void)thread_input;
 
  wifi_hal_puts("wifi_hal: port_init=");
  wifi_hal_puts(ra8_err_to_str(s_init_err));
  wifi_hal_puts("\r\n");
  if (s_init_err != k_ra8_ok) {
    wifi_hal_puts("wifi_hal: FAIL port init failed -- no transaction attempted\r\n");
    wifi_hal_heartbeat(false);
    return;
  }
 
  ra8_delay_ms((uint32_t)k_wifi_hal_boot_wait_ms);
 
  ra8_net_credentials_t credentials = {};
  const ra8_err_t provisioned = ra8_net_provision_receive(&s_provision_uart,
                                                          (uint32_t)k_ra8_net_provision_timeout_ms,
                                                          &credentials);
  if (provisioned != k_ra8_ok) {
    wifi_hal_puts("wifi_hal: FAIL runtime provisioning err=");
    wifi_hal_puts(ra8_err_to_str(provisioned));
    wifi_hal_puts("\r\n");
    ra8_net_provision_clear(&credentials);
    wifi_hal_puts(k_wifi_hal_fail_line);
    wifi_hal_heartbeat(false);
    return;
  }
 
  const bool ok = wifi_hal_run(&credentials);
  ra8_net_provision_clear(&credentials);
  wifi_hal_puts(ok ? k_wifi_hal_pass_line : k_wifi_hal_fail_line);
  wifi_hal_heartbeat(ok);
}

void tx_application_define(void* first_unused_memory)
{
  (void)first_unused_memory;
 
  const ra8_esp_hosted_port_cfg_t cfg = {
    .pclk_hz      = s_pclka_hz,
    .sck_hz       = (uint32_t)k_wifi_hal_sck_hz,
    .edge_poll_ms = (uint16_t)k_wifi_hal_edge_poll_ms,
    .sci_channel  = (uint8_t)k_ra8_board_pmod1_sci_channel,
  };
  s_init_err = ra8_esp_hosted_port_init(&cfg);
 
  if (tx_thread_create(&s_worker,
                       s_worker_name,
                       wifi_hal_worker_entry,
                       0U,
                       s_worker_stack,
                       (ULONG)sizeof(s_worker_stack),
                       (UINT)k_wifi_hal_worker_prio,
                       (UINT)k_wifi_hal_worker_prio,
                       TX_NO_TIME_SLICE,
                       TX_AUTO_START) != TX_SUCCESS) {
    wifi_hal_puts("wifi_hal: worker thread creation failed\r\n");
  }
}

void main(void)
{
  wifi_hal_setup_or_halt();
  ra8_isr_globals_enable();
 
  wifi_hal_print_banner(s_cpuclk_hz, s_pclka_hz);
  wifi_hal_puts("wifi_hal: entering ThreadX; port init runs from tx_application_define\r\n");
 
  tx_kernel_enter();
 
  wifi_hal_panic_halt();
}