main.c

Go to the documentation of this file.

 
#include <stddef.h>
#include <stdint.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_isr.h"
#include "ra8_modem_at.h"
#include "ra8_mstp.h"
#include "ra8_port_utils.h"
#include "ra8_sci.h"
#include "ra8_time.h"
 
/* =============================================================================
 * App-wide tunables
 * =============================================================================
 */

typedef enum : uint32_t {
  k_modem_baud         = 115200U, 
  k_modem_console_baud = 115200U, 
  k_modem_heartbeat_ms = 500U,    
  k_modem_dec_base     = 10U,     
  k_modem_uart_channel = (uint32_t)k_ra8_board_mikrobus_uart_sci_channel,
} modem_const_t;

typedef enum : uint16_t {
  k_modem_cmd_timeout_ms = 2000U, 
} modem_timeout_t;

typedef enum : uint32_t {
  k_modem_dec_cap     = 10U, 
  k_modem_capture_cap = 64U, 
  k_modem_scan_max    = 64U, 
} modem_cap_t;

typedef enum : uint8_t {
  k_modem_csq_min_bars = 5U,  
  k_modem_csq_max      = 31U, 
  k_modem_csq_unknown  = 99U, 
} modem_csq_t;

typedef enum : uint8_t {
  k_modem_creg_not_registered = 0U, 
  k_modem_creg_home           = 1U, 
  k_modem_creg_searching      = 2U, 
  k_modem_creg_denied         = 3U, 
  k_modem_creg_unknown        = 4U, 
  k_modem_creg_roaming        = 5U, 
} modem_creg_stat_t;

typedef enum : uint8_t {
  k_modem_cgatt_detached = 0U, 
  k_modem_cgatt_attached = 1U, 
} modem_cgatt_t;
 
/* =============================================================================
 * Module state (file scope -- NASA P10 Rule 6)
 * =============================================================================
 */

static uint8_t s_creg_stat;

static bool s_creg_seen;
 
/* Banner strings scraped by ra8_emulator / the HIL rig. The success line is
 * "modem: rssi=17 reg=1 attach=1 cme=ok PASS"; a failed verdict swaps PASS for
 * FAIL and reflects the actual cme= token. */
static const uint8_t k_modem_banner_prefix[] = "modem: rssi=";
static const uint8_t k_modem_str_reg[]       = " reg=";
static const uint8_t k_modem_str_attach[]    = " attach=";
static const uint8_t k_modem_str_cme[]       = " cme=";
static const uint8_t k_modem_str_ok[]        = "ok";
static const uint8_t k_modem_str_no[]        = "no";
static const uint8_t k_modem_str_pass[]      = " PASS\r\n";
static const uint8_t k_modem_str_fail[]      = " FAIL\r\n";
 
/* =============================================================================
 * Pure decision logic (mirrored + MC/DC-tested in tests/mocks/src/test_app_modem_at_demo.c)
 * =============================================================================
 */

static bool modem_creg_registered(uint32_t stat)
{
  return (stat == (uint32_t)k_modem_creg_home) || (stat == (uint32_t)k_modem_creg_roaming);
}

static bool modem_signal_valid(uint32_t rssi)
{
  return (rssi != (uint32_t)k_modem_csq_unknown) && (rssi >= (uint32_t)k_modem_csq_min_bars);
}

static bool modem_step_passed(bool is_cme_probe, ra8_err_t err)
{
  return (is_cme_probe && (err == k_ra8_err_hw_error)) || ((!is_cme_probe) && (err == k_ra8_ok));
}

static bool
modem_run_ok(bool sim_ready, bool signal_ok, bool registered, bool attached, bool cme_ok)
{
  return sim_ready && signal_ok && registered && attached && cme_ok;
}
 
/* =============================================================================
 * Pure parsing helpers (also mirrored + tested on the host)
 * =============================================================================
 */

static bool modem_parse_first_uint(const char* line, uint32_t* out)
{
  if ((line == nullptr) || (out == nullptr)) {
    return false;
  }
  uint32_t i = 0U;
  while ((i < (uint32_t)k_modem_scan_max) && (line[i] != '\0') && (line[i] != ':')) {
    i++;
  }
  if ((i >= (uint32_t)k_modem_scan_max) || (line[i] != ':')) {
    return false;
  }
  i++;
  while ((i < (uint32_t)k_modem_scan_max) && (line[i] == ' ')) {
    i++;
  }
  if ((i >= (uint32_t)k_modem_scan_max) || (line[i] < '0') || (line[i] > '9')) {
    return false;
  }
  uint32_t v = 0U;
  while ((i < (uint32_t)k_modem_scan_max) && (line[i] >= '0') && (line[i] <= '9')) {
    v = (v * (uint32_t)k_modem_dec_base) + (uint32_t)(line[i] - '0');
    i++;
  }
  *out = v;
  return true;
}

static bool modem_parse_last_uint(const char* line, uint32_t* out)
{
  if ((line == nullptr) || (out == nullptr)) {
    return false;
  }
  bool     found = false;
  uint32_t v     = 0U;
  uint32_t i     = 0U;
  while ((i < (uint32_t)k_modem_scan_max) && (line[i] != '\0')) {
    if ((line[i] >= '0') && (line[i] <= '9')) {
      v = 0U;
      while ((i < (uint32_t)k_modem_scan_max) && (line[i] >= '0') && (line[i] <= '9')) {
        v = (v * (uint32_t)k_modem_dec_base) + (uint32_t)(line[i] - '0');
        i++;
      }
      found = true;
    } else {
      i++;
    }
  }
  if (found) {
    *out = v;
  }
  return found;
}

static bool modem_line_contains(const char* line, const char* needle)
{
  if ((line == nullptr) || (needle == nullptr)) {
    return false;
  }
  for (uint32_t i = 0U; (i < (uint32_t)k_modem_scan_max) && (line[i] != '\0'); i++) {
    uint32_t j = 0U;
    while ((j < (uint32_t)k_modem_scan_max) && (needle[j] != '\0') && (line[i + j] == needle[j])) {
      j++;
    }
    if (needle[j] == '\0') {
      return true;
    }
  }
  return false;
}
 
/* =============================================================================
 * Small integer serialiser + console emit helpers
 * =============================================================================
 */

static uint32_t modem_u32_to_dec(uint32_t value, uint8_t* out)
{
  uint8_t  tmp[k_modem_dec_cap] = {};
  uint32_t n                    = 0U;
  if (value == 0U) {
    tmp[n] = (uint8_t)'0';
    n++;
  } else {
    while ((value > 0U) && (n < (uint32_t)k_modem_dec_cap)) {
      tmp[n] = (uint8_t)('0' + (uint8_t)(value % (uint32_t)k_modem_dec_base));
      n++;
      value = value / (uint32_t)k_modem_dec_base;
    }
  }
  for (uint32_t i = 0U; i < n; i++) {
    out[i] = tmp[n - 1U - i];
  }
  return n;
}

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

static void modem_emit_kv(const uint8_t* label, uint32_t label_len, uint32_t value)
{
  uint8_t buf[k_modem_dec_cap] = {};
  modem_tx(label, label_len);
  const uint32_t n = modem_u32_to_dec(value, buf);
  modem_tx(buf, n);
}
 
/* =============================================================================
 * ra8_modem_at transport adapters (SCI7, polled)
 * =============================================================================
 */
 
static ra8_err_t modem_tx_byte(void* ctx, uint8_t byte)
{
  (void)ctx;
  return ra8_sci_putc_polling((uint8_t)k_modem_uart_channel, byte);
}
 
static ra8_err_t modem_rx_byte(void* ctx, uint8_t* out_byte)
{
  (void)ctx;
  return ra8_sci_getc_polling((uint8_t)k_modem_uart_channel, out_byte);
}
 
static uint32_t modem_now_ms(void* ctx)
{
  (void)ctx;
  return ra8_now_ms();
}

static void modem_on_creg_urc(const char* line, void* ctx)
{
  (void)ctx;
  if (line == nullptr) {
    return;
  }
  uint32_t stat = 0U;
  if (modem_parse_last_uint(line, &stat)) {
    s_creg_stat = (uint8_t)stat;
    s_creg_seen = true;
  }
}
 
/* =============================================================================
 * Bring-up helpers (kept out of main() for NASA P10 Rule 4)
 * =============================================================================
 */

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

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

static void modem_pfs_or_halt(void)
{
  if (ra8_pfs_route_peripheral((ra8_port_pin_t)k_ra8_board_mikrobus_tx,
                               k_ra8_psel_sci_async,
                               "modem_at_demo.txd7") != k_ra8_ok) {
    modem_panic_halt();
  }
  if (ra8_pfs_route_peripheral((ra8_port_pin_t)k_ra8_board_mikrobus_rx,
                               k_ra8_psel_sci_async,
                               "modem_at_demo.rxd7") != k_ra8_ok) {
    modem_panic_halt();
  }
}

static void modem_setup_or_halt(void)
{
  uint32_t pclka_hz = 0U;
  modem_clocks_or_halt(&pclka_hz);
  modem_pfs_or_halt();
 
  if (ra8_board_uart_console_init((uint32_t)k_modem_console_baud) != k_ra8_ok) {
    modem_panic_halt();
  }
  const ra8_sci_cfg_t cfg = {
    .baud      = (uint32_t)k_modem_baud,
    .data_bits = k_ra8_sci_data_8,
    .parity    = k_ra8_sci_parity_none,
    .stop_bits = k_ra8_sci_stop_1,
    .pclk_hz   = pclka_hz,
  };
  if (ra8_sci_init((uint8_t)k_modem_uart_channel, &cfg) != k_ra8_ok) {
    modem_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led1) != k_ra8_ok) {
    modem_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led2) != k_ra8_ok) {
    modem_panic_halt();
  }
}

static ra8_err_t modem_bind(uint8_t* line_buf, uint16_t line_buf_len)
{
  const ra8_modem_at_cfg_t cfg = {
    .io                 = {.tx_byte = modem_tx_byte,
                           .rx_byte = modem_rx_byte,
                           .now_ms  = modem_now_ms,
                           .ctx     = nullptr},
    .line_buf           = line_buf,
    .line_buf_len       = line_buf_len,
    .default_timeout_ms = (uint16_t)k_modem_cmd_timeout_ms,
  };
  const ra8_err_t ierr = ra8_modem_at_init(&cfg);
  if (ierr != k_ra8_ok) {
    return ierr;
  }
  return ra8_modem_at_register_unsolicited_handler("+CREG:", modem_on_creg_urc, nullptr);
}

static ra8_err_t modem_cmd_ok(const char* cmd)
{
  return ra8_modem_at_send_cmd(cmd, nullptr, (uint16_t)k_modem_cmd_timeout_ms);
}

static ra8_err_t modem_query(const char* cmd, char* buf, size_t cap)
{
  return ra8_modem_at_send_cmd_capture(cmd, buf, cap, (uint16_t)k_modem_cmd_timeout_ms);
}

static void modem_fail(const uint8_t* step, uint32_t step_len)
{
  static const uint8_t k_pfx[] = "modem: ";
  static const uint8_t k_sfx[] = " FAIL\r\n";
  modem_tx(k_pfx, (uint32_t)(sizeof(k_pfx) - 1U));
  modem_tx(step, step_len);
  modem_tx(k_sfx, (uint32_t)(sizeof(k_sfx) - 1U));
  (void)ra8_board_led_on(k_ra8_board_led2);
  modem_panic_halt();
}
 
/* =============================================================================
 * AT script phases
 * =============================================================================
 */

static void modem_phase_sync(void)
{
  static const uint8_t k_step[] = "sync";
  if (modem_cmd_ok("AT") != k_ra8_ok) {
    modem_fail(k_step, (uint32_t)(sizeof(k_step) - 1U));
  }
  if (modem_cmd_ok("ATE0") != k_ra8_ok) {
    modem_fail(k_step, (uint32_t)(sizeof(k_step) - 1U));
  }
  if (modem_cmd_ok("AT+CMEE=1") != k_ra8_ok) {
    modem_fail(k_step, (uint32_t)(sizeof(k_step) - 1U));
  }
}

static bool modem_phase_sim(void)
{
  static const uint8_t k_step[]                 = "cpin";
  char                 buf[k_modem_capture_cap] = {};
  if (modem_query("AT+CPIN?", buf, sizeof buf) != k_ra8_ok) {
    modem_fail(k_step, (uint32_t)(sizeof(k_step) - 1U));
  }
  return modem_line_contains(buf, "READY");
}

static bool modem_phase_signal(uint32_t* out_rssi)
{
  static const uint8_t k_step[]                 = "csq";
  char                 buf[k_modem_capture_cap] = {};
  if (modem_query("AT+CSQ", buf, sizeof buf) != k_ra8_ok) {
    modem_fail(k_step, (uint32_t)(sizeof(k_step) - 1U));
  }
  uint32_t rssi = (uint32_t)k_modem_csq_unknown;
  (void)modem_parse_first_uint(buf, &rssi);
  *out_rssi = rssi;
  modem_emit_kv(k_modem_banner_prefix, (uint32_t)(sizeof(k_modem_banner_prefix) - 1U), rssi);
  return modem_signal_valid(rssi);
}

static bool modem_phase_registration(void)
{
  static const uint8_t k_step[] = "creg";
  if (modem_cmd_ok("AT+CREG=1") != k_ra8_ok) {
    modem_fail(k_step, (uint32_t)(sizeof(k_step) - 1U));
  }
  /* Drain + dispatch the unsolicited "+CREG: <stat>" the modem emits on enable. */
  (void)ra8_modem_at_poll();
  if (modem_cmd_ok("AT+CREG?") != k_ra8_ok) {
    modem_fail(k_step, (uint32_t)(sizeof(k_step) - 1U));
  }
  modem_emit_kv(k_modem_str_reg, (uint32_t)(sizeof(k_modem_str_reg) - 1U), (uint32_t)s_creg_stat);
  return s_creg_seen && modem_creg_registered((uint32_t)s_creg_stat);
}

static bool modem_phase_attach(void)
{
  static const uint8_t k_step[]                 = "cgatt";
  char                 buf[k_modem_capture_cap] = {};
  if (modem_query("AT+CGATT?", buf, sizeof buf) != k_ra8_ok) {
    modem_fail(k_step, (uint32_t)(sizeof(k_step) - 1U));
  }
  uint32_t flag = (uint32_t)k_modem_cgatt_detached;
  (void)modem_parse_first_uint(buf, &flag);
  modem_emit_kv(k_modem_str_attach, (uint32_t)(sizeof(k_modem_str_attach) - 1U), flag);
  return flag == (uint32_t)k_modem_cgatt_attached;
}

static bool modem_phase_error(void)
{
  const ra8_err_t err = modem_cmd_ok("AT+NOSUCHCMD");
  return modem_step_passed(true, err);
}
 
/* =============================================================================
 * Main
 * =============================================================================
 */

void main(void)
{
  modem_setup_or_halt();
  ra8_isr_globals_enable();
 
  static uint8_t s_line[k_modem_capture_cap * 2U];
  if (modem_bind(s_line, (uint16_t)sizeof s_line) != k_ra8_ok) {
    static const uint8_t k_step[] = "init";
    modem_fail(k_step, (uint32_t)(sizeof(k_step) - 1U));
  }
 
  modem_phase_sync();
  const bool sim_ready  = modem_phase_sim();
  uint32_t   rssi       = (uint32_t)k_modem_csq_unknown;
  const bool signal_ok  = modem_phase_signal(&rssi);
  const bool registered = modem_phase_registration();
  const bool attached   = modem_phase_attach();
  const bool cme_ok     = modem_phase_error();
 
  const bool ok = modem_run_ok(sim_ready, signal_ok, registered, attached, cme_ok);
  /* "ok"/"no" are both 2 bytes and " PASS\r\n"/" FAIL\r\n" both 7, so one length
   * expression per pair keeps -Wduplicated-branches happy. */
  modem_tx(k_modem_str_cme, (uint32_t)(sizeof(k_modem_str_cme) - 1U));
  modem_tx(cme_ok ? k_modem_str_ok : k_modem_str_no, (uint32_t)(sizeof(k_modem_str_ok) - 1U));
  modem_tx(ok ? k_modem_str_pass : k_modem_str_fail, (uint32_t)(sizeof(k_modem_str_pass) - 1U));
 
  while (1) {
    (void)ra8_board_led_toggle(k_ra8_board_led1);
    ra8_delay_ms((uint32_t)k_modem_heartbeat_ms);
  }
 
  modem_panic_halt();
}