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_cgc.h"
#include "ra8_err.h"
#include "ra8_gpio_constants.h"
#include "ra8_gpt.h"
#include "ra8_isr.h"
#include "ra8_mstp.h"
#include "ra8_port_constants.h"
#include "ra8_port_utils.h"
#include "ra8_time.h"

typedef enum : uint32_t {
  k_motor_3phase_baud          = 115200U,      
  k_motor_3phase_period        = 0x0000FFFFUL, 
  k_motor_3phase_half_period   = 0x00007FFFUL, 
  k_motor_3phase_dead_time     = 125U,         
  k_motor_3phase_update_ms     = 8U,           
  k_motor_3phase_print_period  = 100U,         
  k_motor_3phase_revolution_ms = 2000U,        
} motor_3phase_config_t;

typedef enum : uint8_t {
  k_motor_3phase_ch_u = 0U, 
  k_motor_3phase_ch_v = 1U, 
  k_motor_3phase_ch_w = 2U, 
} motor_3phase_channel_t;

typedef enum : uint16_t {
  k_motor_3phase_sine_size = 256U, 
  k_motor_3phase_sine_mask = 255U, 
  k_motor_3phase_phase_120 = 85U,  
  k_motor_3phase_phase_240 = 171U, 
} motor_3phase_sine_t;

// TODO(board-rev): no public GTIOC0A on EK-RA8D2 v1; pins conflict with debug UART per UM. Use P105/P103/Pmod-GTIOC10A or a custom carrier board.
static const ra8_port_pin_t s_motor_3phase_pin_u = RA8_PIN(k_ra8_port_4, k_ra8_pin_8);
static const ra8_port_pin_t s_motor_3phase_pin_v = RA8_PIN(k_ra8_port_4, k_ra8_pin_9);
static const ra8_port_pin_t s_motor_3phase_pin_w = RA8_PIN(k_ra8_port_4, k_ra8_pin_10);

static const uint8_t s_motor_3phase_msg_prefix[] = "duty UVW ";
static const uint8_t s_motor_3phase_msg_sep[]    = " ";
static const uint8_t s_motor_3phase_msg_eol[]    = "\r\n";

static uint32_t s_motor_3phase_sine[k_motor_3phase_sine_size];

static uint16_t s_motor_3phase_step;

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

RA8_INTERNAL static void internal_motor_3phase_build_sine(void)
{
  /* Use a Q16 representation of pi and 2*pi for the Bhaskara math. */
  enum : uint64_t {
    k_q16_pi      = 205887ULL,  
    k_q16_two_pi  = 411775ULL,  
    k_q16_5_pi_sq = 3236018ULL, 
    k_q16_one     = 65536ULL,   
    k_q16_numer_k = 16ULL,      
    k_q16_denom_k = 4ULL,       
  };
  const uint64_t period_u64  = k_motor_3phase_period;
  const uint64_t half_period = k_motor_3phase_half_period;
 
  for (uint16_t i = 0U; i < k_motor_3phase_sine_size; i++) {
    const uint64_t theta = ((uint64_t)i * k_q16_two_pi) / k_motor_3phase_sine_size;
    bool           neg   = false;
    uint64_t       x     = theta;
    if (x > k_q16_pi) {
      x   = x - k_q16_pi;
      neg = true;
    }
    const uint64_t pi_minus_x = k_q16_pi - x;
    const uint64_t numer      = k_q16_numer_k * x * pi_minus_x;
    const uint64_t denom_part = k_q16_denom_k * x * pi_minus_x;
    const uint64_t denom      = k_q16_5_pi_sq - denom_part;
    const uint64_t sin_q16    = (denom > 0ULL) ? (numer / denom) : 0ULL;
    const uint64_t scaled     = (sin_q16 * half_period) / k_q16_one;
    uint64_t       duty       = neg ? (half_period - scaled) : (half_period + scaled);
    if (duty > period_u64) {
      duty = period_u64;
    }
    s_motor_3phase_sine[i] = (uint32_t)duty;
  }
}

[[nodiscard]] RA8_INTERNAL static ra8_err_t internal_motor_3phase_pins_init(void)
{
  ra8_err_t err =
    ra8_pfs_route_peripheral(s_motor_3phase_pin_u, k_ra8_psel_gpt0, "motor_3phase.gtioc0a");
  if (err != k_ra8_ok) {
    return err;
  }
  err = ra8_pfs_route_peripheral(s_motor_3phase_pin_v, k_ra8_psel_gpt0, "motor_3phase.gtioc1a");
  if (err != k_ra8_ok) {
    return err;
  }
  return ra8_pfs_route_peripheral(s_motor_3phase_pin_w, k_ra8_psel_gpt0, "motor_3phase.gtioc2a");
}

[[nodiscard]] RA8_INTERNAL static ra8_err_t internal_motor_3phase_pin_configure_all(void)
{
  enum : uint8_t {
    k_phase_count = 3U, 
  };
  const ra8_gpt_pwm_pin_cfg_t pin_cfg = {
    .output_enable    = true,
    .polarity         = k_ra8_gpt_pol_active_high,
    .stop_level       = k_ra8_gpt_stop_low,
    .disable_on_fault = k_ra8_gpt_disable_high_z,
  };
  const uint8_t channels[k_phase_count] = {
    k_motor_3phase_ch_u,
    k_motor_3phase_ch_v,
    k_motor_3phase_ch_w,
  };
  for (uint8_t i = 0U; i < k_phase_count; i++) {
    ra8_err_t err = ra8_gpt_pwm_pin_configure(channels[i], k_ra8_gpt_pin_a, &pin_cfg);
    if (err != k_ra8_ok) {
      return err;
    }
    err = ra8_gpt_dead_time_set(channels[i], k_motor_3phase_dead_time, k_motor_3phase_dead_time);
    if (err != k_ra8_ok) {
      return err;
    }
  }
  return k_ra8_ok;
}

RA8_INTERNAL static void internal_motor_3phase_init_clocks_and_led(void)
{
  uint32_t cpuclk0_hz = 0U;
 
  if (ra8_cgc_init() != k_ra8_ok) {
    internal_motor_3phase_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    internal_motor_3phase_panic_halt();
  }
  if (ra8_mstp_init() != k_ra8_ok) {
    internal_motor_3phase_panic_halt();
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    internal_motor_3phase_panic_halt();
  }
  if (internal_motor_3phase_pins_init() != k_ra8_ok) {
    internal_motor_3phase_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led1) != k_ra8_ok) {
    internal_motor_3phase_panic_halt();
  }
}

RA8_INTERNAL static void internal_motor_3phase_init_console(void)
{
  if (ra8_board_uart_console_init((uint32_t)k_motor_3phase_baud) != k_ra8_ok) {
    internal_motor_3phase_panic_halt();
  }
}

RA8_INTERNAL static void internal_motor_3phase_init_pwm(void)
{
  /* MSTP enable is now performed in internal_motor_3phase_init_clocks_and_led so
   * the canonical CGC -> MSTP -> IOPORT -> TIME -> peripheral order is
   * preserved (see audit_init_order). */
  const ra8_gpt_three_phase_cfg_t three_phase_cfg = {
    .channels       = {k_motor_3phase_ch_u, k_motor_3phase_ch_v, k_motor_3phase_ch_w},
    .mode           = k_ra8_gpt_mode_triangle_pwm,
    .prescaler      = k_ra8_gpt_ps_div_1,
    .period_counts  = k_motor_3phase_period,
    .initial_duty_u = k_motor_3phase_half_period,
    .initial_duty_v = k_motor_3phase_half_period,
    .initial_duty_w = k_motor_3phase_half_period,
  };
  if (ra8_gpt_three_phase_open(&three_phase_cfg) != k_ra8_ok) {
    internal_motor_3phase_panic_halt();
  }
  if (internal_motor_3phase_pin_configure_all() != k_ra8_ok) {
    internal_motor_3phase_panic_halt();
  }
 
  internal_motor_3phase_build_sine();
  s_motor_3phase_step = 0U;
 
  /* Initial test pattern: 50 % duty on all three phases. */
  if (ra8_gpt_three_phase_set_duty(k_motor_3phase_half_period,
                                   k_motor_3phase_half_period,
                                   k_motor_3phase_half_period) != k_ra8_ok) {
    internal_motor_3phase_panic_halt();
  }
}

RA8_INTERNAL static uint32_t internal_motor_3phase_u32_to_dec(uint32_t value, uint8_t* buf)
{
  enum : uint8_t {
    k_ascii_zero = 0x30U, 
    k_radix      = 10U,   
    k_max_digits = 10U,   
  };
  uint8_t  tmp[k_max_digits];
  uint32_t n = 0U;
  if (value == 0U) {
    buf[0] = k_ascii_zero;
    return 1U;
  }
  while (value > 0U) {
    tmp[n] = (uint8_t)(k_ascii_zero + (uint8_t)(value % k_radix));
    n++;
    value /= k_radix;
  }
  for (uint32_t i = 0U; i < n; i++) {
    buf[i] = tmp[n - 1U - i];
  }
  return n;
}

RA8_INTERNAL static void
internal_motor_3phase_print_duty(uint32_t u_duty, uint32_t v_duty, uint32_t w_duty)
{
  enum : uint8_t {
    k_dec_buf = 12U, 
  };
  uint8_t  digits[k_dec_buf];
  uint32_t n = 0U;
 
  (void)ra8_board_uart_console_write(s_motor_3phase_msg_prefix,
                                     (size_t)(sizeof(s_motor_3phase_msg_prefix) - 1U));
  n = internal_motor_3phase_u32_to_dec(u_duty, digits);
  (void)ra8_board_uart_console_write(digits, (size_t)n);
  (void)ra8_board_uart_console_write(s_motor_3phase_msg_sep,
                                     (size_t)(sizeof(s_motor_3phase_msg_sep) - 1U));
  n = internal_motor_3phase_u32_to_dec(v_duty, digits);
  (void)ra8_board_uart_console_write(digits, (size_t)n);
  (void)ra8_board_uart_console_write(s_motor_3phase_msg_sep,
                                     (size_t)(sizeof(s_motor_3phase_msg_sep) - 1U));
  n = internal_motor_3phase_u32_to_dec(w_duty, digits);
  (void)ra8_board_uart_console_write(digits, (size_t)n);
  (void)ra8_board_uart_console_write(s_motor_3phase_msg_eol,
                                     (size_t)(sizeof(s_motor_3phase_msg_eol) - 1U));
}

RA8_INTERNAL static void
internal_motor_3phase_advance(uint32_t* out_u, uint32_t* out_v, uint32_t* out_w)
{
  const uint16_t i_u = s_motor_3phase_step;
  const uint16_t i_v =
    (uint16_t)((s_motor_3phase_step + k_motor_3phase_phase_120) & k_motor_3phase_sine_mask);
  const uint16_t i_w =
    (uint16_t)((s_motor_3phase_step + k_motor_3phase_phase_240) & k_motor_3phase_sine_mask);
  *out_u              = s_motor_3phase_sine[i_u];
  *out_v              = s_motor_3phase_sine[i_v];
  *out_w              = s_motor_3phase_sine[i_w];
  s_motor_3phase_step = (uint16_t)((s_motor_3phase_step + 1U) & k_motor_3phase_sine_mask);
}

void main(void)
{
  internal_motor_3phase_init_clocks_and_led();
  internal_motor_3phase_init_console();
  internal_motor_3phase_init_pwm();
 
  ra8_isr_globals_enable();
 
  uint32_t print_accum_ms = 0U;
 
  while (1) {
    uint32_t u_duty = 0U;
    uint32_t v_duty = 0U;
    uint32_t w_duty = 0U;
 
    internal_motor_3phase_advance(&u_duty, &v_duty, &w_duty);
 
    if (ra8_gpt_three_phase_set_duty(u_duty, v_duty, w_duty) != k_ra8_ok) {
      break;
    }
 
    print_accum_ms += k_motor_3phase_update_ms;
    if (print_accum_ms >= k_motor_3phase_print_period) {
      print_accum_ms = 0U;
      internal_motor_3phase_print_duty(u_duty, v_duty, w_duty);
      (void)ra8_board_led_toggle(k_ra8_board_led1);
    }
 
    ra8_delay_ms(k_motor_3phase_update_ms);
  }
 
  internal_motor_3phase_panic_halt();
}