---

In modern embedded system development, efficient peripheral communication is key to achieving high-performance applications. The ESP32, a powerful dual-core WiFi/Bluetooth chip, supports high-speed data transfer via its SPI interface, especially when combined with DMA (Direct Memory Access) technology. This article provides a step-by-step guide on how to configure SPI with DMA for efficient data transfer using the ESP-IDF framework within the VSCode development environment.

What is SPI DMA?

SPI (Serial Peripheral Interface) is a synchronous serial communication protocol commonly used for short-distance communication between microcontrollers and peripheral devices.

DMA (Direct Memory Access) is a technique that allows peripherals to transfer data directly to/from memory without involving the CPU. This significantly enhances system performance and reduces CPU load.

SPI DMA combines the advantages of both technologies. It leverages the DMA controller to handle SPI data transfers, freeing up the CPU to perform other tasks. This is especially useful in high-bandwidth or real-time applications.

How It Works – A Quick Overview

The operation of SPI DMA can be simplified into the following steps:

1. CPU initializes the SPI and DMA controller
2. CPU sets up data buffer and transfer parameters
3. DMA controller automatically reads data from memory and sends it via SPI
4. Upon completion, DMA triggers an interrupt to notify the CPU
5. CPU handles post-transfer operations or prepares for the next transfer

This approach eliminates the need for the CPU to intervene in the data transfer process, thus significantly improving system efficiency.

Development Environment

Before starting your programming, make sure to complete the following preparations:

• Install ESP-IDF (version 4.4 or higher): ESP-IDF is the official development framework for programming the ESP32, and it supports multiple operating systems such as Windows, macOS, and Linux.
• ESP32 Development Board: An ESP32 board is required.

Project Structure

A typical ESP-IDF project structure looks like this:

spi_dma_demo/
├── CMakeLists.txt
├── main/
│   ├── CMakeLists.txt
│   └── spi_dma_demo.c
├── sdkconfig
└── README.md

Code

Here is the complete code for implementing SPI DMA:

#include "driver/spi_master.h"
#include "driver/gpio.h"
#include "esp_log.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"

#define TAG "SPI_DMA_DEMO"

// SPI pin configuration
#define PIN_NUM_MISO 12
#define PIN_NUM_MOSI 11
#define PIN_NUM_CLK  13
#define PIN_NUM_CS   10

// SPI settings
#define SPI_HOST    SPI2_HOST
#define DMA_CHAN    1
#define SPI_FREQ_HZ 10 * 1000 * 1000  // 10MHz

spi_device_handle_t spi;

void init_spi_with_dma() {
    // 1. Configure the SPI bus
    spi_bus_config_t buscfg = {
        .miso_io_num = PIN_NUM_MISO,
        .mosi_io_num = PIN_NUM_MOSI,
        .sclk_io_num = PIN_NUM_CLK,
        .quadwp_io_num = -1,
        .quadhd_io_num = -1,
        .max_transfer_sz = 4096,  // Max transfer size for DMA
    };

    // 2. Initialize the SPI bus
    ESP_ERROR_CHECK(spi_bus_initialize(SPI_HOST, &buscfg, DMA_CHAN));

    // 3. Attach a device to the SPI bus
    spi_device_interface_config_t devcfg = {
        .clock_speed_hz = SPI_FREQ_HZ,
        .mode = 0,  // SPI mode 0
        .spics_io_num = PIN_NUM_CS,
        .queue_size = 7,  // Transaction queue size
        .pre_cb = NULL,   // Pre-transfer callback (optional)
        .post_cb = NULL,  // Post-transfer callback (optional)
    };

    ESP_ERROR_CHECK(spi_bus_add_device(SPI_HOST, &devcfg, &spi));
}

void spi_dma_transfer(const uint8_t *data, size_t len) {
    // Create a transaction descriptor
    spi_transaction_t t = {
        .length = len * 8,  // Data length in bits
        .tx_buffer = data,
        .user = NULL
    };

    // Queue the transaction
    ESP_ERROR_CHECK(spi_device_queue_trans(spi, &t, portMAX_DELAY));

    // Wait for the transaction to complete
    spi_transaction_t *rtrans;
    ESP_ERROR_CHECK(spi_device_get_trans_result(spi, &rtrans, portMAX_DELAY));

    ESP_LOGI(TAG, "DMA transfer completed, size: %d bytes", len);
}

void app_main() {
    // Initialize SPI with DMA
    init_spi_with_dma();

    // Prepare test data
    uint8_t test_data[256];
    for (int i = 0; i < sizeof(test_data); i++) {
        test_data[i] = i & 0xFF;
    }

    while (1) {
        // Perform DMA transfer
        spi_dma_transfer(test_data, sizeof(test_data));

        // Delay for 1 second
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

Code Explanation

SPI Initialization

• SPI Bus Configuration (spi_bus_config_t)
  Defines the I/O pins and max transfer size.
• SPI Bus Initialization (spi_bus_initialize)
  Initializes the SPI bus with the configuration.
• Device Configuration and Attachment (spi_bus_add_device)
  Sets the device parameters (e.g., speed, SPI mode, CS pin) and attaches the device.

DMA Transfer

• Transaction Descriptor (spi_transaction_t)
  Sets the length (in bits) and points to the transmit buffer.
• Queue Transfer (spi_device_queue_trans)
  Sends the transaction asynchronously to the device queue.
• Get Transfer Result (spi_device_get_trans_result)
  Waits for the queued transaction to complete and retrieves the result.

Compile and Flash

After writing the code, you can use the ESP-IDF tools to build, flash, and monitor:

In the VS Code lower-left ESP-IDF toolbar:

• Click Build project
• Click Flash device
• Click Monitor device

Upon successful execution, the serial monitor will output:

I (285) SPI_DMA_DEMO: DMA transfer completed, size: 256 bytes
I (1285) SPI_DMA_DEMO: DMA transfer completed, size: 256 bytes
I (2285) SPI_DMA_DEMO: DMA transfer completed, size: 256 bytes
...

Conclusion

This guide explored how to harness ESP32’s SPI DMA capabilities to overcome traditional data transfer limitations. This “CPU-bypass” design significantly reduces system overhead and opens new possibilities for high-speed communication.

Using the VSCode + ESP-IDF development environment, we went from low-level configuration to real-world implementation, building an efficient SPI DMA communication solution. This technique is ideal for data-intensive, real-time applications such as industrial sensor collection, high-speed memory access, or smooth graphical display control.

Once you understand the core concepts of SPI DMA, consider exploring double buffering for improved real-time performance, or test parallel processing in FreeRTOS environments to further enhance your ESP32 project’s efficiency.

---