main.c

Go to the documentation of this file.

 
#include <stdint.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"
 
#ifndef RA8_OFF_TARGET
#include "tx_api.h"
#endif
 
/* ---------------------------------------------------------------------------
 * Demo tunables (typed enums per the no-magic-number rule).
 * --------------------------------------------------------------------------- */

typedef enum : uint32_t {
  k_ipc_demo_baud           = 115200U, 
  k_ipc_demo_period_ms      = 1000U,   
  k_ipc_demo_period_ticks   = 1000U,   
  k_ipc_demo_thread_stack   = 2048U,   
  k_ipc_demo_producer_prio  = 5U,      
  k_ipc_demo_consumer_prio  = 4U,      
  k_ipc_demo_queue_capacity = 8U,      
} ipc_demo_cfg_t;

typedef enum : uint32_t {
  k_ipc_demo_payload_ping = 0x676E6970U, 
  k_ipc_demo_payload_pong = 0x676E6F70U, 
} ipc_demo_payload_t;

static const uint8_t k_ipc_demo_banner[]   = "[ipc_demo] M85 starting\r\n";
static const uint8_t k_ipc_demo_send_msg[] = "[ipc_demo] -> ping\r\n";
static const uint8_t k_ipc_demo_recv_msg[] = "[ipc_demo] <- pong\r\n";

volatile uint32_t g_ipc_demo_tick = 0U;
 
/* ---------------------------------------------------------------------------
 * SCI8 helpers.
 * --------------------------------------------------------------------------- */

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

static void ipc_demo_log(const uint8_t* s, uint32_t len)
{
  (void)ra8_board_uart_console_write(s, (size_t)len);
}
 
/* ---------------------------------------------------------------------------
 * Boot path: CGC -> pins -> SCI8.
 * --------------------------------------------------------------------------- */

static void ipc_demo_setup_or_halt(void)
{
  uint32_t cpuclk0_hz = 0U;
 
  if (ra8_cgc_init() != k_ra8_ok) {
    ipc_demo_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    ipc_demo_panic_halt();
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    ipc_demo_panic_halt();
  }
  if (ra8_board_uart_console_init((uint32_t)k_ipc_demo_baud) != k_ra8_ok) {
    ipc_demo_panic_halt();
  }
}
 
/* ---------------------------------------------------------------------------
 * ThreadX bring-up.
 * --------------------------------------------------------------------------- */
 
#ifndef RA8_OFF_TARGET
/* 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. */

static TX_QUEUE s_ipc_queue;
static ULONG    s_ipc_queue_storage[k_ipc_demo_queue_capacity];

static TX_THREAD                   s_producer_thread;
[[gnu::aligned(8)]] static uint8_t s_producer_stack[k_ipc_demo_thread_stack];

static TX_THREAD                   s_consumer_thread;
[[gnu::aligned(8)]] static uint8_t s_consumer_stack[k_ipc_demo_thread_stack];

static void ipc_producer_thread_entry(ULONG thread_input)
{
  (void)thread_input;
 
  ipc_demo_log(k_ipc_demo_banner, (uint32_t)(sizeof(k_ipc_demo_banner) - 1U));
 
  while (1) {
    ULONG msg = (ULONG)k_ipc_demo_payload_ping;
    /* ``tx_queue_send`` arguments: queue ptr, ptr-to-source (NOT the
     * value), wait option. The source pointer is read for exactly
     * ``message_size`` ULONGs as declared at create time. */
    if (tx_queue_send(&s_ipc_queue, &msg, TX_WAIT_FOREVER) == TX_SUCCESS) {
      ipc_demo_log(k_ipc_demo_send_msg, (uint32_t)(sizeof(k_ipc_demo_send_msg) - 1U));
    }
    (void)tx_thread_sleep((ULONG)k_ipc_demo_period_ticks);
  }
}

static void ipc_consumer_thread_entry(ULONG thread_input)
{
  (void)thread_input;
 
  while (1) {
    ULONG msg = 0U;
    if (tx_queue_receive(&s_ipc_queue, &msg, TX_WAIT_FOREVER) != TX_SUCCESS) {
      /* Should not happen with TX_WAIT_FOREVER on a healthy queue,
       * but if it does we skip the log so the HIL negative-regex
       * does not trip on spurious output. */
      continue;
    }
    if (msg != (ULONG)k_ipc_demo_payload_ping) {
      continue;
    }
    ipc_demo_log(k_ipc_demo_recv_msg, (uint32_t)(sizeof(k_ipc_demo_recv_msg) - 1U));
    g_ipc_demo_tick += 1U;
  }
}

void tx_application_define(void* first_unused_memory)
{
  (void)first_unused_memory;
 
  /* ThreadX takes non-const CHAR* for object names; use writable static
   * buffers to avoid -Wdiscarded-qualifiers / -Wcast-qual. */
  static CHAR s_queue_name[]    = "ipc_demo_q";
  static CHAR s_producer_name[] = "producer";
  static CHAR s_consumer_name[] = "consumer";
 
  /* tx_queue_create: message_size is in 32-bit ULONGs (TX_1_ULONG=1),
   * queue_size is the total backing-buffer byte count. Deriving the
   * byte count from sizeof() of the same backing array keeps the two
   * arguments in sync. */
  if (tx_queue_create(&s_ipc_queue,
                      s_queue_name,
                      TX_1_ULONG,
                      s_ipc_queue_storage,
                      (ULONG)sizeof(s_ipc_queue_storage)) != TX_SUCCESS) {
    ipc_demo_panic_halt();
  }
 
  /* Consumer goes first so it is parked in tx_queue_receive before the
   * producer's first send -- avoids a transient queue-not-empty
   * window where the consumer would have to sleep to catch up. */
  if (tx_thread_create(&s_consumer_thread,
                       s_consumer_name,
                       ipc_consumer_thread_entry,
                       0U,
                       s_consumer_stack,
                       (ULONG)k_ipc_demo_thread_stack,
                       (UINT)k_ipc_demo_consumer_prio,
                       (UINT)k_ipc_demo_consumer_prio,
                       TX_NO_TIME_SLICE,
                       TX_AUTO_START) != TX_SUCCESS) {
    ipc_demo_panic_halt();
  }
 
  if (tx_thread_create(&s_producer_thread,
                       s_producer_name,
                       ipc_producer_thread_entry,
                       0U,
                       s_producer_stack,
                       (ULONG)k_ipc_demo_thread_stack,
                       (UINT)k_ipc_demo_producer_prio,
                       (UINT)k_ipc_demo_producer_prio,
                       TX_NO_TIME_SLICE,
                       TX_AUTO_START) != TX_SUCCESS) {
    ipc_demo_panic_halt();
  }
}
#endif /* !RA8_OFF_TARGET */
 
/* ---------------------------------------------------------------------------
 * main()
 * --------------------------------------------------------------------------- */

void main(void)
{
  ipc_demo_setup_or_halt();
 
  ra8_isr_globals_enable();
 
#ifndef RA8_OFF_TARGET
  tx_kernel_enter();
#endif
 
  ipc_demo_panic_halt();
}