Последовательный порт, прямой доступ к памяти и консоль … ↩

void uart1_init(uint32_t baud)
{
    RCC-＞AHB1ENR |= RCC_AHB1ENR_GPIOAEN;
    RCC-＞APB2ENR |= RCC_APB2ENR_USART1EN;            /* USART1 сидит на APB2, 84 МГц */
    (void)RCC-＞APB2ENR;

    /* PA9 и PA10: альтернативная функция AF7 (USART1). */
    GPIOA-＞MODER = (GPIOA-＞MODER & ~(0xFu ＜＜ 18)) | (0xAu ＜＜ 18);
    GPIOA-＞AFR[1] = (GPIOA-＞AFR[1] & ~(0xFFu ＜＜ 4)) | (0x77u ＜＜ 4);

    rb_init(&g_uart_rx, rx_mem, sizeof rx_mem);

    USART1-＞BRR = (84000000u + baud / 2u) / baud;    /* делитель с округлением */
    USART1-＞CR1 = USART_CR1_TE | USART_CR1_RE | USART_CR1_RXNEIE | USART_CR1_UE;
    NVIC_SetPriority(USART1_IRQn, 5);
    NVIC_EnableIRQ(USART1_IRQn);
}

void USART1_IRQHandler(void)
{
    if (USART1-＞SR & USART_SR_RXNE) {
        uint8_t byte = (uint8_t)USART1-＞DR;          /* чтение DR сбрасывает флаг */
        if (!rb_push(&g_uart_rx, byte)) g_uart_rx_overflow++;
    }
}

void uart1_write(const char *s)
{
    while (*s) {
        while (!(USART1-＞SR & USART_SR_TXE)) { }     /* ждать освобождения передатчика */
        USART1-＞DR = (uint8_t)*s++;
    }
}

/* Кольцевой буфер «один писатель — один читатель».
 * Размер — степень двойки, поэтому вместо деления используется маска. */
typedef struct {
    uint8_t          *data;
    uint16_t          mask;    /* размер - 1 */
    volatile uint16_t head;    /* пишет только производитель (прерывание) */
    volatile uint16_t tail;    /* пишет только потребитель (основной цикл) */
} ringbuf_t;

bool     rb_init(ringbuf_t *rb, uint8_t *storage, uint16_t size);
bool     rb_push(ringbuf_t *rb, uint8_t byte);
bool     rb_pop(ringbuf_t *rb, uint8_t *byte);
uint16_t rb_count(const ringbuf_t *rb);

/* Барьер компилятора: запрещает переносить запись данных за изменение индекса. */
#define RB_BARRIER() __asm__ __volatile__("" ::: "memory")

bool rb_init(ringbuf_t *rb, uint8_t *storage, uint16_t size)
{
    if (size == 0 || (size & (size - 1u)) != 0) return false;  /* не степень двойки */
    rb-＞data = storage;
    rb-＞mask = (uint16_t)(size - 1u);
    rb-＞head = rb-＞tail = 0;
    return true;
}

uint16_t rb_count(const ringbuf_t *rb)
{
    return (uint16_t)(rb-＞head - rb-＞tail);     /* индексы растут без ограничения */
}

bool rb_push(ringbuf_t *rb, uint8_t byte)
{
    if (rb_count(rb) == (uint16_t)(rb-＞mask + 1u)) return false;   /* буфер полон */
    rb-＞data[rb-＞head & rb-＞mask] = byte;
    RB_BARRIER();
    rb-＞head++;                     /* индекс меняется только после записи данных */
    return true;
}

bool rb_pop(ringbuf_t *rb, uint8_t *byte)
{
    if (rb-＞head == rb-＞tail) return false;     /* буфер пуст */
    *byte = rb-＞data[rb-＞tail & rb-＞mask];
    RB_BARRIER();
    rb-＞tail++;                     /* место освобождается только после чтения */
    return true;
}

void test_ringbuf_wraps_and_reports_overflow(void)
{
    uint8_t mem[8], b;
    ringbuf_t rb;
    TEST_ASSERT_FALSE(rb_init(&rb, mem, 6));        /* 6 — не степень двойки */
    TEST_ASSERT_TRUE(rb_init(&rb, mem, 8));

    for (int round = 0; round != 100; round++) {    /* многократный переход через край */
        for (uint8_t i = 0; i != 8; i++) TEST_ASSERT_TRUE(rb_push(&rb, i));
        TEST_ASSERT_FALSE(rb_push(&rb, 99));        /* девятый байт не помещается */
        for (uint8_t i = 0; i != 8; i++) {
            TEST_ASSERT_TRUE(rb_pop(&rb, &b));
            TEST_ASSERT_EQUAL_UINT8(i, b);
        }
        TEST_ASSERT_FALSE(rb_pop(&rb, &b));
    }
}

static uint8_t dma_rx[256];     /* в SRAM, а не в CCM: у DMA нет доступа к CCM */
static uint16_t dma_rx_tail;

void uart1_dma_rx_init(void)
{
    RCC-＞AHB1ENR |= RCC_AHB1ENR_DMA2EN;
    (void)RCC-＞AHB1ENR;

    DMA2_Stream2-＞CR = 0;                            /* поток выключается перед настройкой */
    while (DMA2_Stream2-＞CR & DMA_SxCR_EN) { }
    DMA2_Stream2-＞PAR  = (uint32_t)&USART1-＞DR;      /* откуда: регистр данных USART1 */
    DMA2_Stream2-＞M0AR = (uint32_t)dma_rx;           /* куда: буфер в памяти */
    DMA2_Stream2-＞NDTR = sizeof dma_rx;
    DMA2_Stream2-＞CR = (4u ＜＜ DMA_SxCR_CHSEL_Pos)    /* канал 4 потока 2 — USART1_RX */
                     | DMA_SxCR_MINC                 /* адрес в памяти увеличивается */
                     | DMA_SxCR_CIRC;                /* кольцевой режим; направление 00 — из периферии в память */

    USART1-＞CR1 &= ~USART_CR1_RXNEIE;                /* прерывание на каждый байт больше не нужно */
    USART1-＞CR3 |= USART_CR3_DMAR;                   /* USART передаёт принятые байты в DMA */
    DMA2_Stream2-＞CR |= DMA_SxCR_EN;
}

bool uart1_dma_rx_pop(uint8_t *byte)
{
    /* NDTR — сколько байт осталось до конца буфера; отсюда позиция записи DMA. */
    uint16_t head = (uint16_t)(sizeof dma_rx - DMA2_Stream2-＞NDTR);
    if (dma_rx_tail == head) return false;
    *byte = dma_rx[dma_rx_tail];
    dma_rx_tail = (uint16_t)((dma_rx_tail + 1u) % sizeof dma_rx);
    return true;
}

#define CLI_MAX_ARGS 6

/* Делит строку на слова на месте (пробелы заменяются нулями).
 * Знак «=» считается отдельным словом: «set a=1» и «set a = 1» равнозначны. */
int cli_tokenize(char *line, char *argv[], int max_args);

static char eq_token[] = "=";

int cli_tokenize(char *line, char *argv[], int max_args)
{
    int argc = 0;
    char *p = line;

    while (*p != '\0' && argc != max_args) {
        while (*p == ' ' || *p == '\t') *p++ = '\0';      /* пропуск пробелов */
        if (*p == '\0') break;
        if (*p == '=') {                                  /* «=» — отдельное слово */
            *p++ = '\0';
            argv[argc++] = eq_token;
            continue;
        }
        argv[argc++] = p;
        while (*p != '\0' && *p != ' ' && *p != '\t' && *p != '=') p++;
    }
    return argc;
}

void test_cli_tokenize_set_with_and_without_spaces(void)
{
    char a[] = "set  gyro_hz=1000";
    char b[] = "set gyro_hz = 1000";
    char *va[CLI_MAX_ARGS], *vb[CLI_MAX_ARGS];
    TEST_ASSERT_EQUAL_INT(4, cli_tokenize(a, va, CLI_MAX_ARGS));
    TEST_ASSERT_EQUAL_INT(4, cli_tokenize(b, vb, CLI_MAX_ARGS));
    for (int i = 0; i != 4; i++) TEST_ASSERT_EQUAL_STRING(va[i], vb[i]);
    TEST_ASSERT_EQUAL_STRING("=", va[2]);
}