main.c

Go to the documentation of this file.

 
#include <stdint.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_port_constants.h"
#include "ra8_port_utils.h"
 
/*
 * The host unit-test build (RA8_OFF_TARGET) does not link the
 * ThreadX vendor tree, so `tx_api.h` is unreachable when clang-tidy
 * walks this file. Pull it in only on the cross-compile target.
 */
#ifndef RA8_OFF_TARGET
#include "tx_api.h"
#endif
 
/* ---------------------------------------------------------------------------
 * Timer-thread tunables (typed enums per the project's no-magic-number rule).
 * --------------------------------------------------------------------------- */

typedef enum : uint16_t {
  k_blink_thread_stack_bytes = 1024U, 
} blink_stack_t;

typedef enum : uint8_t {
  k_blink_thread_priority = 4U, 
} blink_priority_t;

typedef enum : uint16_t {
  k_blink_a_ticks = 500U,  
  k_blink_b_ticks = 1000U, 
} blink_period_t;
 
#ifndef RA8_OFF_TARGET
/* ---------------------------------------------------------------------------
 * Static thread + stack storage. Only meaningful on the cross build,
 * where TX_THREAD is defined by the ThreadX vendor headers.
 * --------------------------------------------------------------------------- */

[[gnu::aligned(8)]] static uint8_t s_thread_a_stack[k_blink_thread_stack_bytes];

[[gnu::aligned(8)]] static uint8_t s_thread_b_stack[k_blink_thread_stack_bytes];

static TX_THREAD s_thread_a;

static TX_THREAD s_thread_b;

volatile uint32_t g_threadx_blink_tick = 0U;
 
/* SysTick handler lives in libs/ra8_core/src/ra8_time.c -- the project's
 * shared weak SysTick_Handler dispatches to ThreadX (via a weak extern
 * to `_tx_timer_interrupt`) so no per-app override is needed. Closes
 * Issue #8. */
 
/* ---------------------------------------------------------------------------
 * Thread bodies.
 * --------------------------------------------------------------------------- */

RA8_INTERNAL static void internal_thread_a_entry(ULONG thread_input)
{
  (void)thread_input;
  while (1) {
    (void)ra8_board_led_toggle(k_ra8_board_led1);
    g_threadx_blink_tick += 1U;
    (void)tx_thread_sleep((ULONG)k_blink_a_ticks);
  }
}

RA8_INTERNAL static void internal_thread_b_entry(ULONG thread_input)
{
  (void)thread_input;
  while (1) {
    (void)ra8_board_led_toggle(k_ra8_board_led2);
    (void)tx_thread_sleep((ULONG)k_blink_b_ticks);
  }
}
 
/* ---------------------------------------------------------------------------
 * tx_application_define -- ThreadX calls this once, just before the first
 * scheduling decision, with the address of the first byte of unused RAM.
 * Threads are created here, NOT in main(), because the kernel needs them
 * registered before tx_kernel_enter dispatches.
 * --------------------------------------------------------------------------- */

void tx_application_define(void* first_unused_memory)
{
  static CHAR s_thread_a_name[] = "blink_a";
  static CHAR s_thread_b_name[] = "blink_b";
 
  (void)first_unused_memory;
 
  UINT err = tx_thread_create(&s_thread_a,
                              s_thread_a_name,
                              internal_thread_a_entry,
                              0U,
                              s_thread_a_stack,
                              (ULONG)k_blink_thread_stack_bytes,
                              (UINT)k_blink_thread_priority,
                              (UINT)k_blink_thread_priority,
                              TX_NO_TIME_SLICE,
                              TX_AUTO_START);
  if (err != TX_SUCCESS) {
    while (1) {
      __asm__ volatile("wfi");
    }
  }
 
  err = tx_thread_create(&s_thread_b,
                         s_thread_b_name,
                         internal_thread_b_entry,
                         0U,
                         s_thread_b_stack,
                         (ULONG)k_blink_thread_stack_bytes,
                         (UINT)k_blink_thread_priority,
                         (UINT)k_blink_thread_priority,
                         TX_NO_TIME_SLICE,
                         TX_AUTO_START);
  if (err != TX_SUCCESS) {
    while (1) {
      __asm__ volatile("wfi");
    }
  }
}
#endif /* !RA8_OFF_TARGET */
 
/* ---------------------------------------------------------------------------
 * main() -- driver init, then drop into the ThreadX scheduler.
 * --------------------------------------------------------------------------- */

void main(void)
{
  /* CGC bring-up FIRST. tx_initialize_low_level.S programs SysTick
   * with a reload of (1 GHz / 1000 - 1) = 999999 cycles per tick
   * (chip HUM Ch 11 CGC, plus our port/threadx/src/cortex_m85/
   * tx_initialize_low_level.S RA8_BOOT_CLOCK_HZ value). If the chip
   * is still on MOCO (~8.4 MHz) at scheduler-enter time, that
   * 999999-cycle reload takes ~119 ms wallclock instead of 1 ms --
   * a 119x slowdown, which makes tx_thread_sleep(500 ticks) sleep
   * for ~60 s and the LED toggle look frozen in any reasonable
   * HIL window. Bring up the PLL before tx_kernel_enter so the
   * scheduler tick rate matches what tx_user.h declared. */
  if (ra8_cgc_init() != k_ra8_ok) {
    while (1) {
      __asm__ volatile("wfi");
    }
  }
 
  /* GPIO init runs with PRIMASK set; ThreadX will re-enable IRQs once
   * its scheduler is up. */
  if (ra8_board_led_init(k_ra8_board_led1) != k_ra8_ok) {
    while (1) {
      __asm__ volatile("wfi");
    }
  }
  if (ra8_board_led_init(k_ra8_board_led2) != k_ra8_ok) {
    while (1) {
      __asm__ volatile("wfi");
    }
  }
 
  /* Drop into ThreadX. Returns only on internal scheduler error.
   * The host build has no kernel, so it just falls into the WFI loop. */
#ifndef RA8_OFF_TARGET
  tx_kernel_enter();
#endif
 
  /* Belt + suspenders. */
  while (1) {
    __asm__ volatile("wfi");
  }
}