DMA controller concept in Embedded C

Introduction

A DMA controller helps move data quickly inside a computer without using the main processor. This makes programs run faster and saves the processor for other tasks.

When you need to transfer large blocks of data between memory and devices without slowing down the CPU.

When reading data from sensors continuously and storing it in memory automatically.

When sending data to a display or communication port without interrupting the main program.

When you want to improve system efficiency by offloading data movement tasks from the CPU.

Syntax

Embedded C

DMA_Init();
DMA_SetSourceAddress(source_address);
DMA_SetDestinationAddress(destination_address);
DMA_SetTransferSize(size);
DMA_StartTransfer();

This is a general sequence to configure and start a DMA transfer.

Exact function names and parameters depend on the microcontroller and its DMA hardware.

Examples

This example sets up a DMA transfer of 256 bytes from memory address 0x20001000 to 0x40002000.

Embedded C

DMA_Init();
DMA_SetSourceAddress(0x20001000);
DMA_SetDestinationAddress(0x40002000);
DMA_SetTransferSize(256);
DMA_StartTransfer();

This example transfers 128 bytes from an ADC buffer to a memory area using DMA.

Embedded C

DMA_Init();
DMA_SetSourceAddress((uint32_t)&adc_buffer);
DMA_SetDestinationAddress((uint32_t)&memory_area);
DMA_SetTransferSize(128);
DMA_StartTransfer();

Sample Program

This program simulates a DMA controller copying 10 bytes from a source array to a destination array without CPU copying each byte manually.

Embedded C

#include <stdint.h>
#include <stdio.h>

// Simulated DMA controller registers
volatile uint32_t DMA_SRC_ADDR;
volatile uint32_t DMA_DST_ADDR;
volatile uint32_t DMA_SIZE;
volatile uint8_t DMA_START;

// Simulated memory
uint8_t source[10] = {0,1,2,3,4,5,6,7,8,9};
uint8_t destination[10] = {0};

void DMA_Init() {
    // Normally hardware init code here
}

void DMA_SetSourceAddress(uint32_t addr) {
    DMA_SRC_ADDR = addr;
}

void DMA_SetDestinationAddress(uint32_t addr) {
    DMA_DST_ADDR = addr;
}

void DMA_SetTransferSize(uint32_t size) {
    DMA_SIZE = size;
}

void DMA_StartTransfer() {
    // Simulate DMA transfer by copying data
    uint8_t* src = (uint8_t*)DMA_SRC_ADDR;
    uint8_t* dst = (uint8_t*)DMA_DST_ADDR;
    for (uint32_t i = 0; i < DMA_SIZE; i++) {
        dst[i] = src[i];
    }
    DMA_START = 1; // Indicate transfer done
}

int main() {
    DMA_Init();
    DMA_SetSourceAddress((uint32_t)source);
    DMA_SetDestinationAddress((uint32_t)destination);
    DMA_SetTransferSize(10);
    DMA_StartTransfer();

    printf("Destination data after DMA transfer:\n");
    for (int i = 0; i < 10; i++) {
        printf("%d ", destination[i]);
    }
    printf("\n");
    return 0;
}

Important Notes

DMA transfers happen in the background, freeing the CPU to do other work.

Always ensure source and destination addresses are valid and accessible.

DMA size should not exceed the buffer sizes to avoid memory corruption.

Summary

DMA controller moves data automatically without CPU intervention.

It improves speed and efficiency in embedded systems.

Setup involves source, destination, size, and starting the transfer.

Practice

1. What is the main purpose of a DMA controller in embedded systems?

easy

A. To transfer data between memory and peripherals without CPU involvement

B. To execute arithmetic operations faster

C. To manage power consumption of the CPU

D. To handle interrupts from external devices

Solution

1. Step 1: Understand DMA controller role

   A DMA controller is designed to move data automatically without CPU intervention.

2. Step 2: Compare options with DMA function

   Only To transfer data between memory and peripherals without CPU involvement describes data transfer without CPU involvement, which matches DMA's purpose.

3. Final Answer:

   To transfer data between memory and peripherals without CPU involvement -> Option A

4. Quick Check:

   DMA = data transfer without CPU [OK]

Hint: DMA moves data automatically, freeing CPU [OK]

Common Mistakes:

• Confusing DMA with CPU arithmetic operations
• Thinking DMA manages power or interrupts
• Assuming DMA executes code

2. Which of the following is the correct way to start a DMA transfer in embedded C?

easy

A. dma_start(source, destination, size);

B. start_dma(source, destination, size);

C. DMA_Transfer(source, destination, size);

D. dma_transfer(source, destination, size);

Solution

1. Step 1: Identify common DMA function naming

   In embedded C, functions often use lowercase with underscores, like dma_transfer.

2. Step 2: Check syntax correctness

   dma_transfer(source, destination, size); uses a plausible function name and correct parameter order: source, destination, size.

3. Final Answer:

   dma_transfer(source, destination, size); -> Option D

4. Quick Check:

   Correct DMA function syntax = dma_transfer(...) [OK]

Hint: DMA functions usually use lowercase with underscores [OK]

Common Mistakes:

• Using incorrect function names with uppercase letters
• Wrong parameter order
• Assuming DMA functions start with 'start_' prefix

3. Given this code snippet, what will be the value of buffer[0] after DMA transfer?

char source[3] = {10, 20, 30};
char buffer[3] = {0, 0, 0};
dma_transfer(source, buffer, 3);

medium

A. 20

B. 0

C. 10

D. 30

Solution

1. Step 1: Understand dma_transfer behavior

   The function copies data from source to buffer for the given size (3 bytes).

2. Step 2: Check first element after transfer

   buffer[0] will be assigned source[0], which is 10.

3. Final Answer:

   10 -> Option C

4. Quick Check:

   buffer[0] = source[0] = 10 [OK]

Hint: DMA copies source to destination byte-by-byte [OK]

Common Mistakes:

• Assuming buffer remains zero
• Mixing up source and destination
• Using wrong index for buffer

4. Identify the error in this DMA setup code:

uint8_t src[5] = {1,2,3,4,5};
uint8_t dst[5];
dma_transfer(dst, src, 5);

medium

A. Arrays must be declared as volatile

B. Source and destination parameters are swapped

C. Size parameter should be 4, not 5

D. DMA transfer function missing return type

Solution

1. Step 1: Check parameter order in dma_transfer

   Correct order is source first, then destination.

2. Step 2: Analyze given code

   Code calls dma_transfer(dst, src, 5), swapping source and destination.

3. Final Answer:

   Source and destination parameters are swapped -> Option B

4. Quick Check:

   Correct order = source, destination [OK]

Hint: Source comes before destination in DMA calls [OK]

Common Mistakes:

• Mixing source and destination arguments
• Incorrect size parameter
• Assuming volatile needed for arrays

5. You want to transfer a large array of 1000 integers from memory to a peripheral using DMA. Which approach is best to optimize CPU usage?

hard

A. Split the transfer into multiple smaller DMA transfers of 100 integers each

B. Use a single DMA transfer for all 1000 integers at once

C. Copy data manually using a CPU loop instead of DMA

D. Disable DMA and use interrupts for each integer transfer

Solution

1. Step 1: Consider CPU load and DMA transfer size

   Very large DMA transfers may block bus or cause latency; splitting reduces impact.

2. Step 2: Evaluate options for CPU efficiency

   Splitting into smaller chunks allows CPU to handle other tasks between transfers.

3. Final Answer:

   Split the transfer into multiple smaller DMA transfers of 100 integers each -> Option A

4. Quick Check:

   Smaller DMA chunks optimize CPU usage [OK]

Hint: Split large DMA transfers to keep CPU responsive [OK]

Common Mistakes:

• Assuming one big DMA transfer is always best
• Using CPU loops wastes CPU time
• Disabling DMA loses its benefits