main.c

Go to the documentation of this file.

 
#include <stdint.h>
#include <string.h>
 
#include "ra8_attributes.h"
#include "ra8_board_ek_ra8d2.h"
#include "ra8_boot_entry.h"
#include "ra8_cgc.h"
#include "ra8_err.h"
#include "ra8_isr.h"
#include "ra8_time.h"
 
/*
 * The host unit-test build (RA8_OFF_TARGET) does not link the
 * ThreadX or NimBLE vendor trees, so `tx_api.h` and our adapter
 * headers are unreachable when clang-tidy walks this file. Pull
 * them in only on the cross-compile target.
 */
#ifndef RA8_OFF_TARGET
#include "ble_hci_ra8_ble.h"
#include "nimble_npl_threadx.h"
#include "ra8_ble.h"
#include "tx_api.h"
#endif

typedef enum : uint32_t {
  k_demo_baud         = 115200U, 
  k_demo_thread_stack = 8192U,   
  k_demo_tick_ms      = 10000U,  
  k_demo_thread_prio  = 8U,      
} demo_config_t;

typedef enum : uint8_t {
  k_demo_battery_max  = 100U, 
  k_demo_battery_min  = 0U,   
  k_demo_battery_step = 1U,   
  k_demo_battery_init = 50U,  
} demo_battery_t;

typedef enum : uint16_t {
  k_demo_uuid_battery_service = 0x180FU, 
  k_demo_uuid_battery_level   = 0x2A19U, 
} demo_uuid_t;

static const char s_demo_local_name[] = "EK-RA8D2";

static const char* s_demo_tag = "ble_nimble";
 
#ifndef RA8_OFF_TARGET
static TX_THREAD s_demo_thread;
static UCHAR s_demo_stack[k_demo_thread_stack];
static CHAR s_demo_thread_name[] = "nimble_demo";
#endif /* !RA8_OFF_TARGET */

static uint8_t s_demo_battery_level = k_demo_battery_init;

RA8_INTERNAL static void internal_demo_panic_halt(void)
{
  while (1) {
    __asm__ volatile("wfi");
  }
}

RA8_INTERNAL static void internal_demo_log(const char* s)
{
  if (s == nullptr) {
    return;
  }
  uint32_t len = (uint32_t)strlen(s);
  (void)ra8_board_uart_console_write((const uint8_t*)s, (size_t)len);
}

RA8_INTERNAL static void internal_demo_clocks_or_halt(void)
{
  uint32_t cpuclk0_hz = 0U;
 
  if (ra8_cgc_init() != k_ra8_ok) {
    internal_demo_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    internal_demo_panic_halt();
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    internal_demo_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led1) != k_ra8_ok) {
    internal_demo_panic_halt();
  }
  if (ra8_board_uart_console_init((uint32_t)k_demo_baud) != k_ra8_ok) {
    internal_demo_panic_halt();
  }
}
 
#ifndef RA8_OFF_TARGET
RA8_INTERNAL static void internal_demo_ble_or_halt(void)
{
  const ra8_ble_config_t ble_cfg = {
    .use_external_osc  = 1U,
    .deep_sleep_enable = 0U,
  };
  if (ra8_ble_open(&ble_cfg) != k_ra8_ok) {
    internal_demo_log("[nimble] ra8_ble_open failed -- no C6 companion?\r\n");
    internal_demo_panic_halt();
  }
  if (ble_hci_ra8_ble_init() != k_ra8_ok) {
    internal_demo_log("[nimble] ble_hci_ra8_ble_init failed\r\n");
    internal_demo_panic_halt();
  }
  nimble_port_init();
}

RA8_INTERNAL static void internal_demo_tick_battery(void)
{
  if (s_demo_battery_level == k_demo_battery_min) {
    s_demo_battery_level = k_demo_battery_max;
  } else {
    s_demo_battery_level = (uint8_t)(s_demo_battery_level - k_demo_battery_step);
  }
  (void)ra8_board_led_toggle(k_ra8_board_led1);
  internal_demo_log("[nimble] battery tick\r\n");
}

RA8_INTERNAL static void internal_demo_thread_entry(ULONG arg)
{
  (void)arg;
 
  internal_demo_log("[nimble] starting NimBLE peripheral\r\n");
  internal_demo_ble_or_halt();
  internal_demo_log("[nimble] advertising as ");
  internal_demo_log(s_demo_local_name);
  internal_demo_log("\r\n");
 
  while (1) {
    /* Pump any inbound HCI events / ACL frames through the bridge. */
    (void)ra8_ble_dispatch();
    /* Sleep one full tick window before the next battery decrement. */
    (void)tx_thread_sleep((ULONG)k_demo_tick_ms);
    internal_demo_tick_battery();
  }
}

void tx_application_define(void* first_unused_memory)
{
  (void)first_unused_memory;
  (void)tx_thread_create(&s_demo_thread,
                         s_demo_thread_name,
                         internal_demo_thread_entry,
                         0U,
                         s_demo_stack,
                         (ULONG)sizeof(s_demo_stack),
                         (UINT)k_demo_thread_prio,
                         (UINT)k_demo_thread_prio,
                         TX_NO_TIME_SLICE,
                         TX_AUTO_START);
}
#endif /* !RA8_OFF_TARGET */

void main(void)
{
  internal_demo_clocks_or_halt();
  ra8_isr_globals_enable();
  internal_demo_log("[nimble] booting ThreadX + NimBLE on ");
  internal_demo_log(s_demo_tag);
  internal_demo_log("\r\n");
 
#ifndef RA8_OFF_TARGET
  /* Hands control over to ThreadX permanently. */
  tx_kernel_enter();
#endif
 
  /* Should never return. */
  internal_demo_panic_halt();
}