main.c

Go to the documentation of this file.

 
#include <stdint.h>
 
#include "ra8_adc.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"
 
/* TODO: Move this to its own test for 12-bit res and create another test that is 16-bit res:
 * Analog (Datasheet Page 1):
 * 16-bit A/D Converter (ADC16H) x 2, up to 23 channels
 * 12-bit D/A Converter (DAC12) x 2
 * High-Speed Analog Comparator (ACMPHS) x 4
 * Temperature Sensor (TSN)
 */

typedef enum : uint32_t {
  k_adc_b_demo_baud       = 115200U, 
  k_adc_b_demo_period_ms  = 500U,    
  k_adc_b_demo_vref_mv    = 3300U,   
  k_adc_b_demo_full_scale = 4095U,   
} adc_b_demo_const_t;

typedef enum : uint8_t {
  k_adc_b_demo_channel = 0U, 
} adc_b_demo_chan_t;

typedef enum : uint8_t {
  k_adc_b_demo_dec_digits = 5U,   
  k_adc_b_demo_line_max   = 32U,  
  k_adc_b_demo_radix      = 10U,  
  k_adc_b_demo_cr         = '\r', 
  k_adc_b_demo_lf         = '\n', 
} adc_b_demo_fmt_t;
 
static const uint8_t s_adc_b_demo_log_prefix[] = "adc: raw=";
static const uint8_t s_adc_b_demo_mv_sep[]     = " mv=";

static const uint8_t s_adc_b_demo_pass_msg[] = "adc: read PASS\r\n";

RA8_INTERNAL static uint32_t internal_u16_to_dec(uint8_t* buf, uint16_t val)
{
  if (val == 0U) {
    buf[0] = (uint8_t)'0';
    return 1U;
  }
  uint8_t  tmp[k_adc_b_demo_dec_digits];
  uint32_t n = 0U;
  uint16_t v = val;
  while (v != 0U) {
    tmp[n] = (uint8_t)('0' + (uint8_t)(v % (uint16_t)k_adc_b_demo_radix));
    v      = (uint16_t)(v / (uint16_t)k_adc_b_demo_radix);
    n++;
  }
  for (uint32_t i = 0U; i < n; i++) {
    buf[i] = tmp[n - 1U - i];
  }
  return n;
}

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

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_uart_console_init((uint32_t)k_adc_b_demo_baud) != k_ra8_ok) {
    internal_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led1) != k_ra8_ok) {
    internal_panic_halt();
  }
}

[[nodiscard]] RA8_INTERNAL static ra8_err_t internal_arm(void)
{
  const ra8_adc_cfg_t cfg = {
    .resolution    = k_ra8_adc_res_12bit,
    .trigger       = k_ra8_adc_trig_software,
    .right_aligned = true,
    .scan_mode     = false,
  };
  return ra8_adc_init_configured(&cfg);
}

void main(void)
{
  internal_setup_or_halt();
  ra8_isr_globals_enable();
 
  if (internal_arm() != k_ra8_ok) {
    internal_panic_halt();
  }
 
  while (1) {
    uint16_t raw = 0U;
    if (ra8_adc_read_channel((uint8_t)k_adc_b_demo_channel, &raw) != k_ra8_ok) {
      break;
    }
    const uint16_t mv = (uint16_t)(((uint32_t)raw * (uint32_t)k_adc_b_demo_vref_mv) /
                                   (uint32_t)k_adc_b_demo_full_scale);
 
    uint8_t  line[k_adc_b_demo_line_max];
    uint32_t pos = 0U;
    for (uint32_t i = 0U; i < (sizeof(s_adc_b_demo_log_prefix) - 1U); i++) {
      line[pos++] = s_adc_b_demo_log_prefix[i];
    }
    pos += internal_u16_to_dec(&line[pos], raw);
    for (uint32_t i = 0U; i < (sizeof(s_adc_b_demo_mv_sep) - 1U); i++) {
      line[pos++] = s_adc_b_demo_mv_sep[i];
    }
    pos += internal_u16_to_dec(&line[pos], mv);
    line[pos++] = (uint8_t)k_adc_b_demo_cr;
    line[pos++] = (uint8_t)k_adc_b_demo_lf;
 
    (void)ra8_board_uart_console_write(line, (size_t)pos);
    (void)ra8_board_uart_console_write(s_adc_b_demo_pass_msg,
                                       (size_t)(sizeof(s_adc_b_demo_pass_msg) - 1U));
    if (ra8_board_led_toggle(k_ra8_board_led1) != k_ra8_ok) {
      break;
    }
    ra8_delay_ms((uint32_t)k_adc_b_demo_period_ms);
  }
  internal_panic_halt();
}