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

typedef enum : uint32_t {
  k_crc_demo_baud      = 115200U, 
  k_crc_demo_period_ms = 1000U,   
} crc_demo_config_t;

typedef enum : uint32_t {
  k_crc_demo_sw_poly_rev = 0xEDB88320UL, 
  k_crc_demo_sw_init     = 0xFFFFFFFFUL, 
  k_crc_demo_sw_xor_out  = 0xFFFFFFFFUL, 
  k_crc_demo_byte_mask   = 0xFFUL,       
  k_crc_demo_lsb_mask    = 0x1UL,        
} crc_demo_sw_const_t;

typedef enum : uint8_t {
  k_crc_demo_bits_per_byte = 8U,    
  k_crc_demo_nibble_mask   = 0x0FU, 
  k_crc_demo_nibble_shift  = 4U,    
  k_crc_demo_alpha_thresh  = 10U,   
  k_crc_demo_payload_len   = 16U,   
  k_crc_demo_hex_per_word  = 8U,    
} crc_demo_byte_t;

static const uint8_t k_crc_demo_payload[k_crc_demo_payload_len] = {
  0x00U,
  0x11U,
  0x22U,
  0x33U,
  0x44U,
  0x55U,
  0x66U,
  0x77U,
  0x88U,
  0x99U,
  0xAAU,
  0xBBU,
  0xCCU,
  0xDDU,
  0xEEU,
  0xFFU,
};

static const uint8_t k_crc_demo_prefix[]  = "crc: hw=";
static const uint8_t k_crc_demo_sw_tag[]  = " sw=";
static const uint8_t k_crc_demo_ok_tag[]  = " match=Y\r\n";
static const uint8_t k_crc_demo_bad_tag[] = " match=N\r\n";

static const uint8_t k_crc_demo_pass_msg[] = "crc: selftest PASS\r\n";

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

static uint8_t crc_demo_nibble_to_hex(uint8_t nibble)
{
  uint8_t n = (uint8_t)(nibble & (uint8_t)k_crc_demo_nibble_mask);
  if (n < (uint8_t)k_crc_demo_alpha_thresh) {
    return (uint8_t)('0' + n);
  }
  return (uint8_t)('a' + (n - (uint8_t)k_crc_demo_alpha_thresh));
}

static void crc_demo_word_to_hex(uint32_t v, uint8_t* dst)
{
  for (uint8_t i = 0U; i < (uint8_t)k_crc_demo_hex_per_word; ++i) {
    const uint8_t shift =
      (uint8_t)(((uint8_t)k_crc_demo_hex_per_word - 1U - i) * (uint8_t)k_crc_demo_nibble_shift);
    const uint8_t nibble = (uint8_t)((v >> shift) & (uint32_t)k_crc_demo_nibble_mask);
    dst[i]               = crc_demo_nibble_to_hex(nibble);
  }
}

static uint32_t crc_demo_sw_crc32(const uint8_t* data, uint32_t len)
{
  uint32_t crc = (uint32_t)k_crc_demo_sw_init;
  for (uint32_t i = 0U; i < len; ++i) {
    crc ^= (uint32_t)data[i];
    for (uint8_t b = 0U; b < (uint8_t)k_crc_demo_bits_per_byte; ++b) {
      if ((crc & (uint32_t)k_crc_demo_lsb_mask) != 0U) {
        crc = (crc >> 1) ^ (uint32_t)k_crc_demo_sw_poly_rev;
      } else {
        crc = (crc >> 1);
      }
    }
  }
  return crc ^ (uint32_t)k_crc_demo_sw_xor_out;
}

static void crc_demo_setup_or_halt(void)
{
  uint32_t cpuclk0_hz = 0U;
 
  if (ra8_cgc_init() != k_ra8_ok) {
    crc_demo_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    crc_demo_panic_halt();
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    crc_demo_panic_halt();
  }
  if (ra8_board_uart_console_init((uint32_t)k_crc_demo_baud) != k_ra8_ok) {
    crc_demo_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led1) != k_ra8_ok) {
    crc_demo_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led2) != k_ra8_ok) {
    crc_demo_panic_halt();
  }
  if (ra8_crc_init(k_ra8_crc_poly_32_ieee802_3) != k_ra8_ok) {
    crc_demo_panic_halt();
  }
}

[[nodiscard]] static ra8_err_t crc_demo_one_iter(uint8_t* out_match)
{
  uint32_t hw = 0U;
  ra8_crc_reset();
  if (ra8_crc_compute(k_crc_demo_payload, (uint32_t)k_crc_demo_payload_len, &hw) != k_ra8_ok) {
    return k_ra8_err_hw_error;
  }
  const uint32_t sw = crc_demo_sw_crc32(k_crc_demo_payload, (uint32_t)k_crc_demo_payload_len);
 
  uint8_t hwhex[k_crc_demo_hex_per_word] = {};
  uint8_t swhex[k_crc_demo_hex_per_word] = {};
  crc_demo_word_to_hex(hw, hwhex);
  crc_demo_word_to_hex(sw, swhex);
 
  (void)ra8_board_uart_console_write(k_crc_demo_prefix, (size_t)(sizeof(k_crc_demo_prefix) - 1U));
  (void)ra8_board_uart_console_write(hwhex, (size_t)k_crc_demo_hex_per_word);
  (void)ra8_board_uart_console_write(k_crc_demo_sw_tag, (size_t)(sizeof(k_crc_demo_sw_tag) - 1U));
  (void)ra8_board_uart_console_write(swhex, (size_t)k_crc_demo_hex_per_word);
  *out_match = (hw == sw) ? 1U : 0U;
  if (*out_match != 0U) {
    (void)ra8_board_uart_console_write(k_crc_demo_ok_tag, (size_t)(sizeof(k_crc_demo_ok_tag) - 1U));
    (void)ra8_board_uart_console_write(k_crc_demo_pass_msg,
                                       (size_t)(sizeof(k_crc_demo_pass_msg) - 1U));
    return k_ra8_ok;
  }
  (void)ra8_board_uart_console_write(k_crc_demo_bad_tag, (size_t)(sizeof(k_crc_demo_bad_tag) - 1U));
  return k_ra8_ok;
}
 
void main(void)
{
  crc_demo_setup_or_halt();
  ra8_isr_globals_enable();
 
  while (1) {
    uint8_t         match = 0U;
    const ra8_err_t err   = crc_demo_one_iter(&match);
    if (err != k_ra8_ok) {
      break;
    }
    if (match != 0U) {
      (void)ra8_board_led_toggle(k_ra8_board_led1);
    } else {
      (void)ra8_board_led_toggle(k_ra8_board_led2);
    }
    ra8_delay_ms(k_crc_demo_period_ms);
  }
  crc_demo_panic_halt();
}