board_console.c

Go to the documentation of this file.

 
#include "board_console.h"
 
#include <stdint.h>
 
#include "ra8_attributes.h"

typedef struct {
  char     lines[k_board_console_ring_depth][k_board_console_line_cap];
  uint32_t head;  
  uint32_t count; 
  uint32_t total; 
} console_ring_t;

static console_ring_t s_rings[k_board_console_ch_count];

static const char* const s_k_channel_names[k_board_console_ch_count] = {
  "ALL",  
  "UART", 
  "ITM",  
  "RTT",  
  "SPI",  
  "I2C",  
  "CAN",  
  "USB",  
  "SD",   
  "OSPI", 
  "I2S",  
  "ADC",  
  "DAC",  
  "GPIO", 
  "DMA",  
  "NET",  
};
 
const char* board_console_name(board_console_ch_t ch)
{
  if ((uint32_t)ch >= (uint32_t)k_board_console_ch_count) {
    return "?";
  }
  return s_k_channel_names[(uint32_t)ch];
}

RA8_INTERNAL static void internal_slot_copy(char* dst, const char* src)
{
  if (dst == nullptr) {
    return;
  }
  uint32_t i = 0U;
  for (; i < (uint32_t)(k_board_console_line_cap - 1U); i++) {
    if (src == nullptr) {
      break;
    }
    if (src[i] == '\0') {
      break;
    }
    dst[i] = src[i];
  }
  dst[i] = '\0';
}

RA8_INTERNAL static void internal_ring_push(console_ring_t* ring, const char* line)
{
  if (ring == nullptr) {
    return;
  }
  if (ring->head >= (uint32_t)k_board_console_ring_depth) {
    ring->head = 0U; /* defensive: keep the slot index in range */
  }
  internal_slot_copy(ring->lines[ring->head], line);
  ring->head = (ring->head + 1U) % (uint32_t)k_board_console_ring_depth;
  if (ring->count < (uint32_t)k_board_console_ring_depth) {
    ring->count++;
  }
  ring->total++;
}

RA8_INTERNAL static void
internal_format_all_line(board_console_ch_t ch, const char* line, char* out)
{
  if (out == nullptr) {
    return;
  }
  const char* name = board_console_name(ch);
  uint32_t    n    = 0U;
  for (; n < (uint32_t)(k_board_console_line_cap - 1U); n++) {
    if (name[n] == '\0') {
      break;
    }
    out[n] = name[n];
  }
  if (n < (uint32_t)(k_board_console_line_cap - 1U)) {
    out[n] = ' ';
    n++;
  }
  uint32_t j = 0U;
  for (; n < (uint32_t)(k_board_console_line_cap - 1U); n++) {
    if (line == nullptr) {
      break;
    }
    if (line[j] == '\0') {
      break;
    }
    out[n] = line[j];
    j++;
  }
  out[n] = '\0';
}
 
void board_console_push(board_console_ch_t ch, const char* line)
{
  if ((uint32_t)ch == (uint32_t)k_board_console_ch_all) {
    return; /* ALL is a mirror only; never pushed to directly. */
  }
  if ((uint32_t)ch >= (uint32_t)k_board_console_ch_count) {
    return;
  }
  if (line == nullptr) {
    return;
  }
  internal_ring_push(&s_rings[(uint32_t)ch], line);
  char all_line[k_board_console_line_cap];
  internal_format_all_line(ch, line, all_line);
  internal_ring_push(&s_rings[(uint32_t)k_board_console_ch_all], all_line);
}
 
uint32_t board_console_count(board_console_ch_t ch)
{
  if ((uint32_t)ch >= (uint32_t)k_board_console_ch_count) {
    return 0U;
  }
  return s_rings[(uint32_t)ch].count;
}
 
uint32_t board_console_total(board_console_ch_t ch)
{
  if ((uint32_t)ch >= (uint32_t)k_board_console_ch_count) {
    return 0U;
  }
  return s_rings[(uint32_t)ch].total;
}
 
const char* board_console_line(board_console_ch_t ch, uint32_t back)
{
  if ((uint32_t)ch >= (uint32_t)k_board_console_ch_count) {
    return nullptr;
  }
  const console_ring_t* ring = &s_rings[(uint32_t)ch];
  if (back >= ring->count) {
    return nullptr; /* older than the retained history */
  }
  /* back = 0 is the newest line; head points one past the newest. */
  const uint32_t idx = (ring->head + (uint32_t)k_board_console_ring_depth - 1U - back) %
                       (uint32_t)k_board_console_ring_depth;
  return ring->lines[idx];
}
 
void board_console_reset(void)
{
  for (uint32_t ch = 0U; ch < (uint32_t)k_board_console_ch_count; ch++) {
    s_rings[ch].head  = 0U;
    s_rings[ch].count = 0U;
    s_rings[ch].total = 0U;
  }
}