main.c

Go to the documentation of this file.

 
#include <stddef.h>
#include <stdint.h>
#include <string.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_time.h"

typedef enum : uint32_t {
  k_rtt_demo_period_ms = 1000U, 
  k_rtt_up_buf_bytes   = 1024U, 
  k_rtt_down_buf_bytes = 32U,   
  k_rtt_decimal_base   = 10U,   
  k_rtt_max_digits     = 10U,   
  k_rtt_msg_buf_bytes  = 32U,   
} rtt_demo_const_t;

typedef struct {
  const char* name;   
  uint8_t*    buf;    
  uint32_t    size;   
  uint32_t    wr_off; 
  uint32_t    rd_off; 
  uint32_t    flags;  
} rtt_buf_t;

typedef struct {
  char      id[16];   
  uint32_t  max_up;   
  uint32_t  max_down; 
  rtt_buf_t up[1];    
  rtt_buf_t down[1];  
} rtt_cb_t;

static uint8_t s_rtt_up_buf[k_rtt_up_buf_bytes];

static uint8_t s_rtt_down_buf[k_rtt_down_buf_bytes];

static rtt_cb_t s_rtt_cb;

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

RA8_INTERNAL static void internal_init(void)
{
  static const char k_magic[] = {'S', 'E', 'G', 'G', 'E', 'R', ' ', 'R', 'T', 'T', 0};
  for (size_t i = 0U; i < sizeof k_magic; i++) {
    s_rtt_cb.id[i] = k_magic[i];
  }
  s_rtt_cb.max_up         = 1U;
  s_rtt_cb.max_down       = 1U;
  s_rtt_cb.up[0].name     = "Terminal";
  s_rtt_cb.up[0].buf      = s_rtt_up_buf;
  s_rtt_cb.up[0].size     = (uint32_t)k_rtt_up_buf_bytes;
  s_rtt_cb.up[0].wr_off   = 0U;
  s_rtt_cb.up[0].rd_off   = 0U;
  s_rtt_cb.up[0].flags    = 0U;
  s_rtt_cb.down[0].name   = "Terminal";
  s_rtt_cb.down[0].buf    = s_rtt_down_buf;
  s_rtt_cb.down[0].size   = (uint32_t)k_rtt_down_buf_bytes;
  s_rtt_cb.down[0].wr_off = 0U;
  s_rtt_cb.down[0].rd_off = 0U;
  s_rtt_cb.down[0].flags  = 0U;
}

[[nodiscard]] RA8_INTERNAL static ra8_err_t internal_write(const uint8_t* data, uint32_t len)
{
  if (data == nullptr) {
    return k_ra8_err_null_ptr;
  }
  rtt_buf_t* up = &s_rtt_cb.up[0];
  for (uint32_t i = 0U; i < len; i++) {
    uint32_t next = up->wr_off + 1U;
    if (next == up->size) {
      next = 0U;
    }
    if (next == up->rd_off) {
      break; /* host has not drained -- drop the tail. */
    }
    up->buf[up->wr_off] = data[i];
    up->wr_off          = next;
  }
  return k_ra8_ok;
}

RA8_INTERNAL static uint8_t internal_format_line(uint32_t counter, char* buf)
{
  static const char prefix[] = "rtt_log_demo: ";
  uint8_t           n        = 0U;
  for (size_t k = 0U; k < (sizeof prefix - 1U); k++) {
    buf[n++] = prefix[k];
  }
  char     dig[k_rtt_max_digits];
  uint8_t  d   = 0U;
  uint32_t tmp = counter;
  do {
    dig[d++] = (char)('0' + (uint8_t)(tmp % (uint32_t)k_rtt_decimal_base));
    tmp /= (uint32_t)k_rtt_decimal_base;
  } while (tmp != 0U && d < (uint8_t)k_rtt_max_digits);
  while (d > 0U) {
    buf[n++] = dig[--d];
  }
  buf[n++] = '\r';
  buf[n++] = '\n';
  return n;
}

RA8_INTERNAL static void internal_setup_or_halt(void)
{
  uint32_t cpuclk0_hz = 0U;
  if (ra8_cgc_init() != k_ra8_ok) {
    internal_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    internal_panic_halt();
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    internal_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led1) != k_ra8_ok) {
    internal_panic_halt();
  }
  internal_init();
}

void main(void)
{
  internal_setup_or_halt();
  ra8_isr_globals_enable();
 
  uint32_t counter = 0U;
  while (1) {
    char          buf[k_rtt_msg_buf_bytes];
    const uint8_t n = internal_format_line(counter, buf);
    if (internal_write((const uint8_t*)buf, (uint32_t)n) != k_ra8_ok) {
      break;
    }
    if (ra8_board_led_toggle(k_ra8_board_led1) != k_ra8_ok) {
      break;
    }
    counter++;
    ra8_delay_ms(k_rtt_demo_period_ms);
  }
  internal_panic_halt();
}