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_i2c.h"
#include "ra8_isr.h"
#include "ra8_mstp.h"
#include "ra8_time.h"

typedef enum : uint32_t {
  k_riic_target_baud   = 115200U, 
  k_riic_target_bus_hz = 100000U, 
} riic_target_u32_t;

typedef enum : uint8_t {
  k_riic_target_channel   = 1U,    
  k_riic_target_own_addr  = 0x42U, 
  k_riic_target_buf_len   = 8U,    
  k_riic_target_seed_byte = 0xA5U, 
  k_riic_target_seed_len  = 1U,    
} riic_target_u8_t;

typedef struct {
  uint8_t  channel;                   
  uint32_t rx_len;                    
  uint8_t  rx[k_riic_target_buf_len]; 
} riic_target_ctx_t;

static const uint8_t k_riic_target_msg_armed[] = "riic-target: armed 0x42 poll-dispatch\r\n";
static const uint8_t k_riic_target_msg_rx[]    = "riic-target: write serviced\r\n";
static const uint8_t k_riic_target_msg_tx[]    = "riic-target: read serviced\r\n";

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

static void riic_target_on_event(void* vctx, ra8_i2c_peripheral_event_t event)
{
  riic_target_ctx_t* ctx = (riic_target_ctx_t*)vctx;
  if (ctx == nullptr) {
    return;
  }
  if (event == k_ra8_i2c_peripheral_event_write) {
    uint32_t got = 0U;
    (void)ra8_i2c_peripheral_receive(ctx->channel, ctx->rx, (uint32_t)k_riic_target_buf_len, &got);
    if (got > 0U) {
      ctx->rx_len = got;
    }
    (void)ra8_board_uart_console_write(k_riic_target_msg_rx, sizeof(k_riic_target_msg_rx) - 1U);
    (void)ra8_board_led_toggle(k_ra8_board_led1);
    return;
  }
  if (event == k_ra8_i2c_peripheral_event_read) {
    uint32_t sent = 0U;
    (void)ra8_i2c_peripheral_transmit(ctx->channel, ctx->rx, ctx->rx_len, &sent);
    (void)ra8_board_uart_console_write(k_riic_target_msg_tx, sizeof(k_riic_target_msg_tx) - 1U);
    (void)ra8_board_led_toggle(k_ra8_board_led1);
  }
}

static void riic_target_clocks_or_halt(void)
{
  uint32_t cpuclk0_hz = 0U;
  if (ra8_cgc_init() != k_ra8_ok) {
    riic_target_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    riic_target_panic_halt();
  }
  if (ra8_mstp_init() != k_ra8_ok) {
    riic_target_panic_halt();
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    riic_target_panic_halt();
  }
}

static void riic_target_setup_or_halt(void)
{
  riic_target_clocks_or_halt();
 
  if (ra8_board_uart_console_init((uint32_t)k_riic_target_baud) != k_ra8_ok) {
    riic_target_panic_halt();
  }
  if (ra8_board_io_expander_apply_project_sw4_defaults() != k_ra8_ok) {
    riic_target_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led1) != k_ra8_ok) {
    riic_target_panic_halt();
  }
}

[[nodiscard]] static ra8_err_t riic_target_arm(riic_target_ctx_t* ctx)
{
  if (ctx == nullptr) {
    return k_ra8_err_null_ptr;
  }
  const ra8_err_t attached =
    ra8_i2c_peripheral_attach_handler((uint8_t)k_riic_target_channel, riic_target_on_event, ctx);
  if (attached != k_ra8_ok) {
    return attached;
  }
  const ra8_i2c_peripheral_cfg_t cfg = {
    .own_addr_7b   = (uint8_t)k_riic_target_own_addr,
    .slot          = k_ra8_i2c_peripheral_slot_0,
    .general_call  = false,
    .clock_stretch = true,
    .irq_enable    = false, /* polled dispatch, no NVIC wiring */
  };
  return ra8_i2c_peripheral_init((uint8_t)k_riic_target_channel, &cfg);
}

void main(void)
{
  riic_target_setup_or_halt();
  ra8_isr_globals_enable();
 
  static riic_target_ctx_t s_ctx = {
    .channel = (uint8_t)k_riic_target_channel,
    .rx_len  = (uint32_t)k_riic_target_seed_len,
    .rx      = {(uint8_t)k_riic_target_seed_byte},
  };
  if (riic_target_arm(&s_ctx) != k_ra8_ok) {
    riic_target_panic_halt();
  }
  if (ra8_board_uart_console_write(k_riic_target_msg_armed, sizeof(k_riic_target_msg_armed) - 1U) !=
      k_ra8_ok) {
    riic_target_panic_halt();
  }
 
  while (1) {
    ra8_i2c_peripheral_dispatch((uint8_t)k_riic_target_channel);
  }
 
  riic_target_panic_halt();
}