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_canfd.h"
#include "ra8_cgc.h"
#include "ra8_err.h"
#include "ra8_isr.h"
#include "ra8_port_constants.h"
#include "ra8_port_utils.h"
 
#ifndef RA8_OFF_TARGET
#include "tx_api.h"
#endif
 
/* ---------------------------------------------------------------------------
 * Tunables (typed enums per the no-magic-number rule).
 * --------------------------------------------------------------------------- */

typedef enum : uint8_t {
  k_canfd_marker_0 = 0xA5U, 
  k_canfd_marker_1 = 0x5AU, 
  k_canfd_marker_2 = 0x12U, 
  k_canfd_marker_3 = 0x34U, 
  k_canfd_marker_4 = 0x56U, 
  k_canfd_marker_5 = 0x78U, 
  k_canfd_marker_6 = 0x9AU, 
} canfd_marker_t;
 
typedef enum : uint16_t {
  k_canfd_thread_stack_bytes = 1024U, 
} canfd_stack_t;

typedef enum : uint8_t {
  k_canfd_thread_priority = 4U, 
} canfd_priority_t;

typedef enum : uint16_t {
  k_canfd_heartbeat_ticks = 500U,   
  k_canfd_rx_poll_ticks   = 50U,    
  k_canfd_heartbeat_id    = 0x123U, 
  k_canfd_heartbeat_dlc   = 8U,     
} canfd_period_t;

typedef enum : uint32_t {
  k_canfd_demo_channel = 0U,      
  k_canfd_demo_bitrate = 500000U, 
} canfd_link_t;
 
/* 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. */
 
#ifndef RA8_OFF_TARGET
[[gnu::aligned(8)]] static uint8_t s_thread_tx_stack[k_canfd_thread_stack_bytes];
[[gnu::aligned(8)]] static uint8_t s_thread_rx_stack[k_canfd_thread_stack_bytes];
static TX_THREAD                   s_thread_tx;
static TX_THREAD                   s_thread_rx;

volatile uint32_t g_threadx_canfd_match = 0U;

volatile uint32_t g_threadx_canfd_mismatch = 0U;

RA8_INTERNAL static void internal_thread_tx_entry(ULONG thread_input)
{
  (void)thread_input;
  uint8_t seq = 0U;
  while (1) {
    ra8_canfd_frame_t tx = {
      .id          = (uint32_t)k_canfd_heartbeat_id,
      .dlc         = (uint8_t)k_canfd_heartbeat_dlc,
      .is_extended = 0U,
      .is_fd       = 0U,
      .is_brs      = 0U,
      .data        = {seq,
                      k_canfd_marker_0,
                      k_canfd_marker_1,
                      k_canfd_marker_2,
                      k_canfd_marker_3,
                      k_canfd_marker_4,
                      k_canfd_marker_5,
                      k_canfd_marker_6},
    };
    if (ra8_canfd_transmit((uint8_t)k_canfd_demo_channel, &tx) == k_ra8_ok) {
      (void)ra8_board_led_toggle(k_ra8_board_led1);
      g_threadx_canfd_match += 1U;
    } else {
      g_threadx_canfd_mismatch += 1U;
    }
    seq++;
    (void)tx_thread_sleep((ULONG)k_canfd_heartbeat_ticks);
  }
}

RA8_INTERNAL static void internal_thread_rx_entry(ULONG thread_input)
{
  (void)thread_input;
  while (1) {
    ra8_canfd_frame_t rx  = {};
    const ra8_err_t   err = ra8_canfd_receive((uint8_t)k_canfd_demo_channel, &rx);
    if (err == k_ra8_ok) {
      (void)ra8_board_led_toggle(k_ra8_board_led2);
      g_threadx_canfd_match += 1U;
    } else if (err != k_ra8_err_no_data) {
      g_threadx_canfd_mismatch += 1U;
    }
    (void)tx_thread_sleep((ULONG)k_canfd_rx_poll_ticks);
  }
}

void tx_application_define(void* first_unused_memory)
{
  static CHAR s_thread_tx_name[] = "canfd_tx";
  static CHAR s_thread_rx_name[] = "canfd_rx";
 
  (void)first_unused_memory;
 
  UINT err = tx_thread_create(&s_thread_tx,
                              s_thread_tx_name,
                              internal_thread_tx_entry,
                              0U,
                              s_thread_tx_stack,
                              (ULONG)k_canfd_thread_stack_bytes,
                              (UINT)k_canfd_thread_priority,
                              (UINT)k_canfd_thread_priority,
                              TX_NO_TIME_SLICE,
                              TX_AUTO_START);
  if (err != TX_SUCCESS) {
    while (1) {
      __asm__ volatile("wfi");
    }
  }
 
  err = tx_thread_create(&s_thread_rx,
                         s_thread_rx_name,
                         internal_thread_rx_entry,
                         0U,
                         s_thread_rx_stack,
                         (ULONG)k_canfd_thread_stack_bytes,
                         (UINT)k_canfd_thread_priority,
                         (UINT)k_canfd_thread_priority,
                         TX_NO_TIME_SLICE,
                         TX_AUTO_START);
  if (err != TX_SUCCESS) {
    while (1) {
      __asm__ volatile("wfi");
    }
  }
}
#endif /* !RA8_OFF_TARGET */

void main(void)
{
  /* CGC bring-up FIRST so the ThreadX SysTick reload (programmed in
   * tx_initialize_low_level.S assuming RA8_BOOT_CLOCK_HZ = 1 GHz)
   * ticks at the intended 1 ms wallclock cadence. On MOCO (~8.4 MHz)
   * the tick rate would be 1/119 the expected, making
   * tx_thread_sleep(...) ~119x slower than the ms value declared in
   * source. */
  if (ra8_cgc_init() != k_ra8_ok) {
    while (1) {
      __asm__ volatile("wfi");
    }
  }
 
  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");
    }
  }
 
  if (ra8_canfd_init((uint8_t)k_canfd_demo_channel) != k_ra8_ok) {
    while (1) {
      __asm__ volatile("wfi");
    }
  }
  if (ra8_canfd_set_bitrate((uint8_t)k_canfd_demo_channel,
                            (uint32_t)k_canfd_demo_bitrate,
                            (uint32_t)k_canfd_demo_bitrate) != k_ra8_ok) {
    while (1) {
      __asm__ volatile("wfi");
    }
  }
  /* Internal-loopback (HUM Ch 41 "CFDCnCTR" p 2710): TX frames echo
   * into RX so this single-board demo can validate the round trip
   * without a second CAN node on the bus. */
  if (ra8_canfd_set_test_mode((uint8_t)k_canfd_demo_channel, k_ra8_ctms_self_test_1) != k_ra8_ok) {
    while (1) {
      __asm__ volatile("wfi");
    }
  }
 
  ra8_isr_globals_enable();
 
#ifndef RA8_OFF_TARGET
  tx_kernel_enter();
#endif
 
  while (1) {
    __asm__ volatile("wfi");
  }
}