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_err.h"
#include "ra8_i3c.h"
#include "ra8_isr.h"
#include "ra8_lsm6dso.h"
#include "ra8_mstp.h"
#include "ra8_port_utils.h"
#include "ra8_time.h"
 
/* =============================================================================
 * App-wide tunables
 * =============================================================================
 */

typedef enum : uint32_t {
  k_imu_decimal_base   = 10U,     
  k_imu_demo_baud      = 115200U, 
  k_imu_demo_period_ms = 250U,    
  k_imu_demo_bus_hz    = 100000U, 
  k_imu_demo_iic_channel =
    (uint32_t)k_ra8_board_mikrobus_iic_b_channel, 
} imu_demo_const_t;

static const ra8_port_pin_t k_imu_demo_pin_scl = (ra8_port_pin_t)k_ra8_board_mikrobus_i2c_scl;
static const ra8_port_pin_t k_imu_demo_pin_sda = (ra8_port_pin_t)k_ra8_board_mikrobus_i2c_sda;
 
/* =============================================================================
 * Tiny printf-equivalents for HIL log scraping
 * =============================================================================
 */

static const uint8_t k_imu_demo_banner_ok[]  = "lsm6dso: who_am_i=0x6c\r\n";
static const uint8_t k_imu_demo_banner_bad[] = "lsm6dso: who_am_i mismatch\r\n";
static const uint8_t k_imu_demo_banner_nak[] = "lsm6dso: I2C NAK\r\n";
static const uint8_t k_imu_demo_banner_err[] = "lsm6dso: read error\r\n";

static void imu_demo_panic_halt(void)
{
  while (1) {
    __asm__ volatile("wfi");
  }
}
 
/* =============================================================================
 * Tiny integer -> decimal serialiser for the periodic log line
 * =============================================================================
 */

typedef enum : uint32_t {
  k_imu_demo_int_str_cap = 8U, 
} imu_demo_str_cap_t;

static uint32_t imu_demo_i32_to_dec(int32_t value, uint8_t* out)
{
  uint8_t  tmp[k_imu_demo_int_str_cap] = {};
  uint32_t n                           = 0U;
  bool     neg                         = false;
  /* Two's complement edge case: INT16_MIN.  We work in int32_t so we
   * have headroom to negate. */
  int32_t v = value;
  if (v < 0) {
    neg = true;
    v   = -v;
  }
  if (v == 0) {
    tmp[n++] = (uint8_t)'0';
  } else {
    while (v > 0 && n < (uint32_t)k_imu_demo_int_str_cap) {
      tmp[n++] = (uint8_t)('0' + (uint8_t)((uint32_t)v % k_imu_decimal_base));
      v        = (int32_t)((uint32_t)v / k_imu_decimal_base);
    }
  }
  if (neg && n < (uint32_t)k_imu_demo_int_str_cap) {
    tmp[n++] = (uint8_t)'-';
  }
  /* Reverse into the caller's buffer. */
  for (uint32_t i = 0U; i < n; ++i) {
    out[i] = tmp[n - 1U - i];
  }
  if (n < (uint32_t)k_imu_demo_int_str_cap) {
    out[n] = 0U;
  }
  return n;
}
 
/* =============================================================================
 * IIC_B bus adapter for the ra8_lsm6dso transport interface
 * =============================================================================
 */

typedef struct {
  uint8_t channel; 
  uint8_t addr7;   
} imu_demo_iic_ctx_t;

static ra8_err_t imu_demo_iic_read(void* ctx, uint8_t reg, uint8_t* buf, uint32_t len)
{
  const imu_demo_iic_ctx_t* c = (const imu_demo_iic_ctx_t*)ctx;
  return ra8_i3c_transfer(c->channel, c->addr7, &reg, 1U, buf, len);
}

typedef enum : uint32_t {
  k_imu_demo_iic_tx_cap = 16U, 
} imu_demo_iic_cap_t;
 
static ra8_err_t imu_demo_iic_write(void* ctx, uint8_t reg, const uint8_t* buf, uint32_t len)
{
  if (len > (uint32_t)k_imu_demo_iic_tx_cap - 1U) {
    return k_ra8_err_invalid_arg;
  }
  uint8_t scratch[k_imu_demo_iic_tx_cap] = {};
  scratch[0]                             = reg;
  for (uint32_t i = 0U; i < len; ++i) {
    scratch[i + 1U] = buf[i];
  }
  const imu_demo_iic_ctx_t* c = (const imu_demo_iic_ctx_t*)ctx;
  return ra8_i3c_write(c->channel, c->addr7, scratch, len + 1U, false);
}
 
/* =============================================================================
 * Init helpers
 * =============================================================================
 */

static void imu_demo_clocks_or_halt(uint32_t* out_pclka_hz)
{
  uint32_t cpuclk0_hz = 0U;
  if (ra8_cgc_init() != k_ra8_ok) {
    imu_demo_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    imu_demo_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_pclka, out_pclka_hz) != k_ra8_ok) {
    imu_demo_panic_halt();
  }
  if (ra8_mstp_init() != k_ra8_ok) {
    imu_demo_panic_halt();
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    imu_demo_panic_halt();
  }
}

static void imu_demo_pfs_or_halt(void)
{
  if (ra8_pfs_route_peripheral(k_imu_demo_pin_scl, k_ra8_psel_iic, "imu_demo.scl1") != k_ra8_ok) {
    imu_demo_panic_halt();
  }
  if (ra8_pfs_route_peripheral(k_imu_demo_pin_sda, k_ra8_psel_iic, "imu_demo.sda1") != k_ra8_ok) {
    imu_demo_panic_halt();
  }
}

static void imu_demo_setup_or_halt(void)
{
  uint32_t pclka_hz = 0U;
  imu_demo_clocks_or_halt(&pclka_hz);
  imu_demo_pfs_or_halt();
 
  if (ra8_board_uart_console_init((uint32_t)k_imu_demo_baud) != k_ra8_ok) {
    imu_demo_panic_halt();
  }
  const ra8_i3c_cfg_t iic_cfg = {
    .mode     = k_ra8_i3c_mode_i2c,
    .bus_hz   = k_imu_demo_bus_hz,
    .pclka_hz = pclka_hz,
  };
  if (ra8_i3c_init((uint8_t)k_imu_demo_iic_channel, &iic_cfg) != k_ra8_ok) {
    imu_demo_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led1) != k_ra8_ok) {
    imu_demo_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led2) != k_ra8_ok) {
    imu_demo_panic_halt();
  }
}

static void imu_demo_tx(const uint8_t* bytes, uint32_t len)
{
  (void)ra8_board_uart_console_write(bytes, (size_t)len);
}

static void imu_demo_emit_kv(const uint8_t* label, uint32_t label_len, int32_t value)
{
  uint8_t buf[k_imu_demo_int_str_cap] = {};
  imu_demo_tx(label, label_len);
  const uint32_t n = imu_demo_i32_to_dec(value, buf);
  imu_demo_tx(buf, n);
}
 
/* =============================================================================
 * Main-loop helpers (kept out of main() to satisfy NASA P10 Rule 4).
 * =============================================================================
 */

static void imu_demo_check_who_am_i(ra8_lsm6dso_t* dev)
{
  uint8_t         who = 0U;
  const ra8_err_t r   = ra8_lsm6dso_who_am_i(dev, &who);
  if (r != k_ra8_ok) {
    imu_demo_tx(k_imu_demo_banner_nak, (uint32_t)(sizeof(k_imu_demo_banner_nak) - 1U));
    (void)ra8_board_led_on(k_ra8_board_led2);
    imu_demo_panic_halt();
  }
  if (who != (uint8_t)k_lsm6dso_who_am_i_value) {
    imu_demo_tx(k_imu_demo_banner_bad, (uint32_t)(sizeof(k_imu_demo_banner_bad) - 1U));
    (void)ra8_board_led_on(k_ra8_board_led2);
    imu_demo_panic_halt();
  }
  imu_demo_tx(k_imu_demo_banner_ok, (uint32_t)(sizeof(k_imu_demo_banner_ok) - 1U));
}

static void imu_demo_configure(ra8_lsm6dso_t* dev)
{
  if (ra8_lsm6dso_set_accel_range(dev, k_lsm6dso_xl_fs_2g) != k_ra8_ok) {
    (void)ra8_board_led_on(k_ra8_board_led2);
    imu_demo_panic_halt();
  }
  if (ra8_lsm6dso_set_gyro_range(dev, k_lsm6dso_g_fs_250dps) != k_ra8_ok) {
    (void)ra8_board_led_on(k_ra8_board_led2);
    imu_demo_panic_halt();
  }
  if (ra8_lsm6dso_set_odr(dev, k_lsm6dso_odr_104hz) != k_ra8_ok) {
    (void)ra8_board_led_on(k_ra8_board_led2);
    imu_demo_panic_halt();
  }
}

static void imu_demo_sample_and_emit(ra8_lsm6dso_t* dev)
{
  static const uint8_t k_label_prefix[]  = "lsm6dso: ax=";
  static const uint8_t k_label_ay[]      = " ay=";
  static const uint8_t k_label_az[]      = " az=";
  static const uint8_t k_label_gx[]      = " gx=";
  static const uint8_t k_label_gy[]      = " gy=";
  static const uint8_t k_label_gz[]      = " gz=";
  static const uint8_t k_label_temp[]    = " temp=";
  static const uint8_t k_label_newline[] = "\r\n";
 
  ra8_lsm6dso_xyz_t a      = {};
  ra8_lsm6dso_xyz_t g      = {};
  int32_t           tcenti = 0;
  const ra8_err_t   ra     = ra8_lsm6dso_read_accel(dev, &a);
  const ra8_err_t   rg     = ra8_lsm6dso_read_gyro(dev, &g);
  const ra8_err_t   rt     = ra8_lsm6dso_read_temp(dev, &tcenti);
  if (ra != k_ra8_ok || rg != k_ra8_ok || rt != k_ra8_ok) {
    imu_demo_tx(k_imu_demo_banner_err, (uint32_t)(sizeof(k_imu_demo_banner_err) - 1U));
    (void)ra8_board_led_on(k_ra8_board_led2);
    return;
  }
  imu_demo_emit_kv(k_label_prefix, (uint32_t)(sizeof(k_label_prefix) - 1U), a.x);
  imu_demo_emit_kv(k_label_ay, (uint32_t)(sizeof(k_label_ay) - 1U), a.y);
  imu_demo_emit_kv(k_label_az, (uint32_t)(sizeof(k_label_az) - 1U), a.z);
  imu_demo_emit_kv(k_label_gx, (uint32_t)(sizeof(k_label_gx) - 1U), g.x);
  imu_demo_emit_kv(k_label_gy, (uint32_t)(sizeof(k_label_gy) - 1U), g.y);
  imu_demo_emit_kv(k_label_gz, (uint32_t)(sizeof(k_label_gz) - 1U), g.z);
  imu_demo_emit_kv(k_label_temp, (uint32_t)(sizeof(k_label_temp) - 1U), tcenti);
  imu_demo_tx(k_label_newline, (uint32_t)(sizeof(k_label_newline) - 1U));
}
 
/* =============================================================================
 * Main
 * =============================================================================
 */

void main(void)
{
  imu_demo_setup_or_halt();
  ra8_isr_globals_enable();
 
  imu_demo_iic_ctx_t ctx = {
    .channel = (uint8_t)k_imu_demo_iic_channel,
    .addr7   = (uint8_t)k_lsm6dso_i2c_addr_sa0_high,
  };
  const ra8_lsm6dso_bus_t bus = {
    .read_regs  = imu_demo_iic_read,
    .write_regs = imu_demo_iic_write,
    .ctx        = &ctx,
  };
  ra8_lsm6dso_t dev = {};
  if (ra8_lsm6dso_init(&dev, &bus) != k_ra8_ok) {
    imu_demo_tx(k_imu_demo_banner_err, (uint32_t)(sizeof(k_imu_demo_banner_err) - 1U));
    (void)ra8_board_led_on(k_ra8_board_led2);
    imu_demo_panic_halt();
  }
 
  imu_demo_check_who_am_i(&dev);
  /* Configure: +-2 g, +-250 dps, 104 Hz. */
  imu_demo_configure(&dev);
 
  while (1) {
    imu_demo_sample_and_emit(&dev);
    (void)ra8_board_led_toggle(k_ra8_board_led1);
    ra8_delay_ms(k_imu_demo_period_ms);
  }
 
  imu_demo_panic_halt();
}