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_canfd_regs.h"
#include "ra8_cgc.h"
#include "ra8_err.h"
#include "ra8_isr.h"
#include "ra8_time.h"

typedef enum : uint32_t {
  k_canfd_demo_period_ms = 1000U,   
  k_canfd_demo_bitrate   = 500000U, 
  k_canfd_demo_id        = 0x123U,  
  k_canfd_demo_rx_spin   = 200000U, 
} canfd_demo_const_t;

typedef enum : uint8_t {
  k_canfd_demo_channel = 0U, 
  k_canfd_demo_dlc     = 8U, 
} canfd_demo_layout_t;

typedef enum : uint8_t {
  k_canfd_demo_payload_b1 = 0xA5U, 
  k_canfd_demo_payload_b2 = 0x5AU, 
  k_canfd_demo_payload_b3 = 0xFFU, 
  k_canfd_demo_payload_b4 = 0x00U, 
  k_canfd_demo_payload_b5 = 0xDEU, 
  k_canfd_demo_payload_b6 = 0xADU, 
  k_canfd_demo_payload_b7 = 0xBEU, 
} canfd_demo_payload_t;
 
/* CFDC[0].CTR test-mode bits live in ra8_canfd_set_test_mode() now.
 * Bit positions (CTME = bit 24, CTMS = bits [26:25]) and the
 * Self-test 1 / internal-loopback selector (CTMS = 11b) come from
 * HUM Ch 41 "CFDCnCTR" p 2710. */

volatile uint32_t g_canfd_match = 0U;

volatile uint32_t g_canfd_mismatch = 0U;

volatile uint32_t g_canfd_init_step = 0U;

volatile uint32_t g_canfd_ncfg_after_setbitrate = 0U;

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

[[nodiscard]] RA8_INTERNAL static ra8_err_t
internal_canfd_demo_enable_internal_loopback(uint8_t channel)
{
  return ra8_canfd_set_test_mode(channel, k_ra8_ctms_self_test_1);
}

RA8_INTERNAL static void internal_canfd_demo_setup_or_halt(void)
{
  uint32_t cpuclk0_hz = 0U;
  if (ra8_cgc_init() != k_ra8_ok) {
    internal_canfd_demo_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    internal_canfd_demo_panic_halt();
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    internal_canfd_demo_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led1) != k_ra8_ok) {
    internal_canfd_demo_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led2) != k_ra8_ok) {
    internal_canfd_demo_panic_halt();
  }
  if (ra8_canfd_init((uint8_t)k_canfd_demo_channel) != k_ra8_ok) {
    internal_canfd_demo_panic_halt();
  }
  g_canfd_init_step = 1U;
  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) {
    internal_canfd_demo_panic_halt();
  }
  g_canfd_init_step             = 2U;
  g_canfd_ncfg_after_setbitrate = ra8_canfd((uint8_t)k_canfd_demo_channel)->CFDC[0].NCFG;
  if (internal_canfd_demo_enable_internal_loopback((uint8_t)k_canfd_demo_channel) != k_ra8_ok) {
    internal_canfd_demo_panic_halt();
  }
  g_canfd_init_step = 3U;
}

[[nodiscard]] RA8_INTERNAL static ra8_err_t internal_canfd_demo_one_round_trip(uint8_t seq)
{
  ra8_canfd_frame_t tx = {
    .id          = (uint32_t)k_canfd_demo_id,
    .dlc         = (uint8_t)k_canfd_demo_dlc,
    .is_extended = 0U,
    .is_fd       = 0U,
    .is_brs      = 0U,
    .data        = {seq,
                    (uint8_t)k_canfd_demo_payload_b1,
                    (uint8_t)k_canfd_demo_payload_b2,
                    (uint8_t)k_canfd_demo_payload_b3,
                    (uint8_t)k_canfd_demo_payload_b4,
                    (uint8_t)k_canfd_demo_payload_b5,
                    (uint8_t)k_canfd_demo_payload_b6,
                    (uint8_t)k_canfd_demo_payload_b7},
  };
  if (ra8_canfd_transmit((uint8_t)k_canfd_demo_channel, &tx) != k_ra8_ok) {
    return k_ra8_err_hw_error;
  }
  /* Poll for the loopback frame: 500 kbit/s + 8 data bytes ~ 240 us
   * round-trip, so wait up to ~10 ms before declaring no_data. */
  ra8_canfd_frame_t rx = {};
  for (uint32_t i = 0U; i < (uint32_t)k_canfd_demo_rx_spin; i++) {
    if (ra8_canfd_receive((uint8_t)k_canfd_demo_channel, &rx) == k_ra8_ok) {
      return k_ra8_ok;
    }
  }
  return k_ra8_err_no_data;
}
 
void main(void)
{
  internal_canfd_demo_setup_or_halt();
  ra8_isr_globals_enable();
 
  uint8_t seq = 0U;
  while (1) {
    if (internal_canfd_demo_one_round_trip(seq) == k_ra8_ok) {
      (void)ra8_board_led_toggle(k_ra8_board_led1);
      g_canfd_match += 1U;
    } else {
      (void)ra8_board_led_toggle(k_ra8_board_led2);
      g_canfd_mismatch += 1U;
    }
    seq++;
    ra8_delay_ms(k_canfd_demo_period_ms);
  }
  internal_canfd_demo_panic_halt();
}