STM32 DMA 完全ガイド
UART・SPI・ADC との連携で
CPU負荷を最小化

/* main.c の MX_DMA_Init() */
static void MX_DMA_Init(void)
{
    __HAL_RCC_DMA1_CLK_ENABLE();

    HAL_NVIC_SetPriority(DMA1_Stream5_IRQn, 5, 0);  // 優先度は5以上推奨（FreeRTOS併用時）
    HAL_NVIC_EnableIRQ(DMA1_Stream5_IRQn);
}

/* USART2_Init() 内に追加される DMA 連結 */
hdma_usart2_rx.Instance = DMA1_Stream5;
hdma_usart2_rx.Init.Channel = DMA_CHANNEL_4;
hdma_usart2_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;
hdma_usart2_rx.Init.PeriphInc = DMA_PINC_DISABLE;
hdma_usart2_rx.Init.MemInc = DMA_MINC_ENABLE;
hdma_usart2_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
hdma_usart2_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
hdma_usart2_rx.Init.Mode = DMA_CIRCULAR;
hdma_usart2_rx.Init.Priority = DMA_PRIORITY_MEDIUM;
HAL_DMA_Init(&hdma_usart2_rx);

__HAL_LINKDMA(&huart2, hdmarx, hdma_usart2_rx);

/* 送信DMA：最大512バイトのバッファにログを作り、実長(strlen)を非同期送信 */
uint8_t log_buf[512];
sprintf((char*)log_buf, "tick=%lu, temp=%.2f, ...\r\n", HAL_GetTick(), temp);

HAL_UART_Transmit_DMA(&huart2, log_buf, strlen((char*)log_buf));
// この時点でCPUは別処理を実行可能

/* 送信完了コールバック */
void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
{
    if (huart->Instance == USART2) {
        // 送信完了処理（次のバッファを送信、フラグを立てるなど）
    }
}

#define RX_BUF_SIZE 256
uint8_t rx_buf[RX_BUF_SIZE];
volatile uint16_t rx_old_pos = 0;

void StartReceiveDmaIdle(void)
{
    /* IDLE割り込みを有効化 */
    __HAL_UART_ENABLE_IT(&huart2, UART_IT_IDLE);
    /* DMA Circular モードで連続受信開始 */
    HAL_UART_Receive_DMA(&huart2, rx_buf, RX_BUF_SIZE);
}

/* USART2 割込みハンドラ（stm32xxxx_it.c） */
void USART2_IRQHandler(void)
{
    /* IDLE フラグが立っていれば受信終了とみなす */
    if (__HAL_UART_GET_FLAG(&huart2, UART_FLAG_IDLE)) {
        __HAL_UART_CLEAR_IDLEFLAG(&huart2);
        ProcessReceivedData();
    }
    HAL_UART_IRQHandler(&huart2);
}

void ProcessReceivedData(void)
{
    /* DMA残カウンタから現在の書き込み位置を計算 */
    uint16_t pos = RX_BUF_SIZE - __HAL_DMA_GET_COUNTER(huart2.hdmarx);

    if (pos != rx_old_pos) {
        if (pos > rx_old_pos) {
            /* 通常領域 */
            HandleFrame(&rx_buf[rx_old_pos], pos - rx_old_pos);
        } else {
            /* リング末尾 → 先頭にラップしたケース */
            HandleFrame(&rx_buf[rx_old_pos], RX_BUF_SIZE - rx_old_pos);
            HandleFrame(&rx_buf[0], pos);
        }
        rx_old_pos = pos;
    }
}

/* SPI 全二重 DMA 転送 */
uint8_t spi_tx_buf[1024];
uint8_t spi_rx_buf[1024];

HAL_GPIO_WritePin(CS_GPIO_Port, CS_Pin, GPIO_PIN_RESET);   // CS Low
HAL_SPI_TransmitReceive_DMA(&hspi1, spi_tx_buf, spi_rx_buf, 1024);
// CPUは別処理を進められる

/* 転送完了コールバック */
void HAL_SPI_TxRxCpltCallback(SPI_HandleTypeDef *hspi)
{
    if (hspi->Instance == SPI1) {
        HAL_GPIO_WritePin(CS_GPIO_Port, CS_Pin, GPIO_PIN_SET);  // CS High
        // 受信データ処理
    }
}

#define LCD_W 320
#define LCD_H 240
uint16_t lcd_framebuffer[LCD_W * LCD_H];  // 150KB

void Lcd_UpdateFrame(void)
{
    Lcd_SetWindow(0, 0, LCD_W - 1, LCD_H - 1);
    Lcd_DcPin(GPIO_PIN_SET);   // Data モード
    HAL_GPIO_WritePin(CS_GPIO_Port, CS_Pin, GPIO_PIN_RESET);

    /* 16bit幅、150KB相当を一気にDMA送信 */
    HAL_SPI_Transmit_DMA(&hspi1, (uint8_t*)lcd_framebuffer, LCD_W * LCD_H * 2);
}

#define ADC_BUF_SIZE 1024
uint16_t adc_buf[ADC_BUF_SIZE];

/* 起動時 */
HAL_ADC_Start_DMA(&hadc1, (uint32_t*)adc_buf, ADC_BUF_SIZE);

/* バッファ半分埋まった時 */
void HAL_ADC_ConvHalfCpltCallback(ADC_HandleTypeDef *hadc)
{
    if (hadc->Instance == ADC1) {
        // 前半 512 サンプルを処理（後半はDMAが書き込み中なので安全）
        ProcessSamples(&adc_buf[0], ADC_BUF_SIZE / 2);
    }
}

/* バッファ全部埋まった時 */
void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef *hadc)
{
    if (hadc->Instance == ADC1) {
        // 後半 512 サンプルを処理
        ProcessSamples(&adc_buf[ADC_BUF_SIZE / 2], ADC_BUF_SIZE / 2);
    }
}

#define N_CHANNELS 4
#define N_SAMPLES  100

uint16_t adc_buf[N_SAMPLES * N_CHANNELS];  // ch0, ch1, ch4, ch8 の順に格納

HAL_ADC_Start_DMA(&hadc1, (uint32_t*)adc_buf, N_SAMPLES * N_CHANNELS);

/* 100サンプル × 4ch 取得完了 */
void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef *hadc)
{
    /* 各チャネル平均値を計算 */
    uint32_t sum[N_CHANNELS] = {0};
    for (int i = 0; i < N_SAMPLES; i++) {
        for (int ch = 0; ch < N_CHANNELS; ch++) {
            sum[ch] += adc_buf[i * N_CHANNELS + ch];
        }
    }
    for (int ch = 0; ch < N_CHANNELS; ch++) {
        avg[ch] = sum[ch] / N_SAMPLES;
    }
}

uint16_t buf_a[1024];
uint16_t buf_b[1024];

/* HALではダブルバッファ用関数を使用 */
HAL_DMAEx_MultiBufferStart_IT(
    &hdma_adc1,
    (uint32_t)&hadc1.Instance->DR,
    (uint32_t)buf_a,
    (uint32_t)buf_b,
    1024
);

/* M0完了：buf_a が満杯になった */
void HAL_DMAEx_M0CpltCallback(DMA_HandleTypeDef *hdma) {
    Process(buf_a, 1024);  // この間DMAはbuf_bを埋めている
}

/* M1完了：buf_b が満杯になった */
void HAL_DMAEx_M1CpltCallback(DMA_HandleTypeDef *hdma) {
    Process(buf_b, 1024);
}