এই পর্বে যা শিখবেন
- CPU দিয়ে নমুনা নেওয়া আর কপি করার আসল খরচ কোর্সের board-এ মেপে দেখা, আর কোথায় তা ভেঙে পড়ে
- একটি আধুনিক MCU-র DMA channel-এর গঠন: request-acknowledge, arbiter, bus matrix, আর 8237-এর সঙ্গে পার্থক্য
- STM32F103-এর CPAR, CMAR, CNDTR আর CCR হিসাব করে ADC → SRAM-এর circular DMA সাজানো
- Half-transfer আর transfer-complete interrupt দিয়ে double buffering, আর তার সময়ের শর্ত
- Memory-to-memory, priority, transfer error, cache আর
volatile-এর নিয়ম, আর কখন DMA দরকার নেই
১ · CPU যখন নিজেই কুলি — নমুনা নেওয়ার আসল দাম
কমলাপুর রেলস্টেশনে ট্রেন থামলে মালপত্র নামায় কুলিরা। স্টেশনমাস্টার যদি নিজেই প্রতিটি বস্তা কাঁধে নিতেন, তাহলে ঘোষণা দেওয়া, টিকিট মেলানো, সিগন্যাল দেওয়া, সব কাজ থেমে থাকত। আর ঠিক যখন তিনি একটি ফোনে ব্যস্ত, তখন একটি বস্তা প্ল্যাটফর্মেই পড়ে থাকত। Microcontroller-এর CPU সেই স্টেশনমাস্টার। ADC, UART বা SPI থেকে প্রতিটি byte যদি CPU নিজে register থেকে পড়ে মেমরিতে রাখে, তাহলে দুটি দাম দিতে হয়: CPU-র সময়, আর CPU ব্যস্ত থাকলে data হারানোর ঝুঁকি।
বাজারঘরের smart scale-এর কথা ধরুন। Reference lab-এর scale.c প্রতি 100 ms-এ চারটি রূপান্তর গড় করে (README, “বাজারঘর devices”). কিন্তু ধরুন আমরা load cell-এর কাঁপুনি ভালোভাবে ছাঁকতে প্রতি 1 ms-এ একটি নমুনা চাই, আর পরে একটি digital filter চালাব (পর্ব ৬৮)। নমুনাগুলো জমবে একটি ring buffer-এ, যার নকশা পর্ব ৩৯-এ দেখেছেন। DMA আসার আগের পুরোনো, সরল পথ: SysTick-এর প্রতি tick-এ একটি ISR ADC চালু করে, ফলের অপেক্ষা করে, DR পড়ে ring-এ রাখে।
লেখার নিয়ম আর lab: এই পর্বে hex লেখা হয় C-র ধাঁচে, যেমন 0x4001244C. কোর্সের virtual বাজারঘর board BG-M3-এ কোনো DMA controller নেই (reference lab-এর README-র memory map-এ শুধু GPIO, EXTI, SysTick, UART, ADC, I2C-ধাঁচের bus আর watchdog). তাই দুটি উৎস: (১) board-এর আসল run, যেখানে CPU নিজে কাজ করে, “DMA-র আগে”-র মাপকাঠি হিসেবে; firmware C-তে, Clang 22.1.8 (PyPI ziglang 0.17.1, MIT; LLVM অংশ Apache-2.0 with LLVM exception) দিয়ে compile করা, Unicorn 2.1.4 (binding BSD, engine GPLv2)-এ চালানো। (২) STM32F1-এর DMA channel-এর একটি মডেল, Python-এ লেখা, ST-এর reference manual RM0008-এর অধ্যায় ১৩ অনুসারে; এটি আসল silicon নয়, আর এর “bus access” গোনা কোনো আসল chip-এর clock cycle নয়। হাতে কোনো আসল board বা logic analyzer ছিল না।
void SysTick_Handler(void) /* প্রতি 1 ms */
{
ADC1->CR = ADC_CR_ADON | ADC_CR_SWSTART; /* রূপান্তর শুরু */
while ((ADC1->SR & ADC_SR_EOC) == 0u) { } /* শেষের অপেক্ষা */
ring[head % RING] = (uint16_t)ADC1->DR; /* CPU নিজেই কপি করে */
head++;
isr_cycles = (SystemCoreClock / 1000u - 1u) - SysTick->VAL;
}
/* main: ১২টি নমুনার পরে একটি লম্বা critical section */
while (head < 12u) __WFI();
SIMCTRL->MARK = 1;
__disable_irq();
for (volatile uint32_t i = 0; i < 5600u; i++) { } /* about 4.7 ms here */
__enable_irq();
SIMCTRL->MARK = 2;
while (head < 24u) __WFI();
SIMCTRL->MARK = 3;সত্যিকারের run · Clang 22.1.8 (ziglang 0.17.1), Unicorn 2.1.4, বাজারঘর board BG-M3
$ python -B board.py build ~/lab/fw/adc_ring.c -o ~/lab/build/adc_ring.elf
$ python -B board.py run ~/lab/build/adc_ring.elf --script ~/lab/fw/adc_ring.json
[ 0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[ 0.0000 ms] > load on the scale: 0 g
[ 5.5000 ms] > load on the scale: 150 g
[ 12.0124 ms] MARK 1
[ 16.7420 ms] MARK 2
[ 17.5000 ms] > load on the scale: 1400 g
[ 27.0123 ms] MARK 3
[ 27.0414 ms] UART: ISR cycles per sample = 20
[ 27.0589 ms] UART: samples = 24
[ 27.2721 ms] UART: ring: 1380 1380 1380 1380 1380 1380 1380 1380 505 505 505 505 505 505 1380 1380
[ 27.2727 ms] exit(0) after 218182 cycles
তিনটি জিনিস লক্ষ করুন। এক, প্রতিটি নমুনায় ISR মাত্র 20 cycle নিয়েছে: SysTick-এর ঘড়ি LOAD = 7999 থেকে নামে, তাই ISR-এর শেষে VAL পড়ে 7999 − VAL = শুরু থেকে কত cycle গেল। 8 MHz-এ 1 kHz নমুনায় এটি 20 × 1000 ÷ 8 000 000 = 0.25% CPU. খুব কম মনে হয়, কিন্তু board-এ ADC-র রূপান্তর তাৎক্ষণিক আর exception-এ ঢোকা 0 cycle (Spec decision 17 আর 25); আসল Cortex-M3-এ শুধু exception-এ ঢুকতেই প্রায় ১২ cycle, আর ADC-র রূপান্তরের অপেক্ষা আলাদা। তা ছাড়া খরচ নমুনার হারের সমানুপাতিক: একই 20 cycle-এ 10 kHz-এ 2.5%, 100 kHz-এ 25%, আর 400 kHz-এ পুরো 100%, CPU আর কিছুই করতে পারবে না।
দুই, 27 ms-এ ২৭টি tick হওয়ার কথা, নমুনা ২৪টি: তিনটি হারিয়েছে। কারণ main 12.0124 থেকে 16.7420 ms পর্যন্ত, প্রায় ৪.৭ ms, interrupt বন্ধ রেখেছিল (critical section). এর মধ্যে 13, 14, 15 আর 16 ms-এ চারটি SysTick এসেছে, কিন্তু Cortex-M-এ একটি exception-এর “pending” মাত্র একটি বিট: চারবার এলেও মনে থাকে একবার। Interrupt খোলার সঙ্গে সঙ্গে একটি নমুনা নেওয়া হলো, বাকি তিনটি চিরতরে গেল। তিন, ring-এর শেষ ছবি সেটি নিশ্চিত করে: ঘর ৮ থেকে ১৩ পর্যন্ত 505 (150 g, কারণ raw = 400 + 0.7 × 150 = 505), ঘর ১৪–১৫ আর ০–৭-এ 1380 (1400 g). নমুনা না হারালে 1400 g আসার আগেই ring অন্যভাবে ভরত। নিচের stepper-এ প্রতিটি মুহূর্ত দেখুন।
| সময় | |
| ঘটনা | |
| SysTick pending | |
| head (নমুনা) | |
| ring-এ মান | |
| হারানো |
- স্বাভাবিক চলা। প্রতি 1 ms-এ SysTick, ISR 20 cycle-এ একটি নমুনা নেয়। 5.5 ms পর্যন্ত মাল নেই (raw 400), 6 ms-এর tick থেকে 150 g-এর থালা (raw 505). 12 ms-এর পরে head = 12.
- লম্বা critical section শুরু। 12.0124 ms-এ main
__disable_irq()চালায় (Cortex-M-এরcpsid i, PRIMASK = 1). এখন কোনো সাধারণ exception CPU-তে ঢুকতে পারবে না। - প্রথম tick আটকে গেল। 13 ms-এ SysTick-এর counter শূন্যে পৌঁছায়; exception pending হয় (ICSR-এর PENDSTSET-এর মতো একটি বিট), কিন্তু চলে না।
- আরও তিনটি tick. 14, 15, 16 ms-এ আবার শূন্য, কিন্তু pending বিট আগেই 1; একটি বিট গুনতে পারে না। এই তিনটি নমুনার সুযোগ চলে গেল, কোনো error-ও এল না।
- Interrupt খোলা। 16.7420 ms-এ
cpsie i; জমে থাকা একমাত্র SysTick সঙ্গে সঙ্গে চলে, নমুনা ১৩ নেয় (তখনও 150 g, তাই 505). আমার lab-এর আলাদা যাচাই-run-এ এই নমুনার MARK এসেছিল 16.7435 ms-এ। - শেষ হিসাব। 27.0123 ms-এ head = 24, অথচ tick হয়েছে ২৭টি। Ring-এর ঘর ৮–১৩-এ 505, ঘর ১৪–১৫ আর ০–৭-এ 1380: 17.5 ms-এ 1400 g আসার পরের নমুনা। নিয়মিত নমুনার সময়-ব্যবধান ভেঙে গেছে, filter-এর হিসাবও ভুল হবে।
এই সমস্যার দুটি পরিচিত ওষুধ আছে: critical section ছোট রাখা আর ISR-কে বেশি priority দেওয়া, যা পর্ব ৪৩ (Interrupt আর ISR নকশা)-এর বিষয়। কিন্তু মূল প্রশ্নটি থেকে যায়: একটি নমুনা register থেকে মেমরিতে নিতে CPU-র দরকার কেন? এই প্রশ্নের উত্তরই DMA.
২ · DMA কী — 8237 থেকে আজকের microcontroller
DMA (direct memory access) মানে চিপের ভেতরে একটি আলাদা ছোট যন্ত্র, যে নিজেই ঠিকানা দিয়ে পড়তে আর লিখতে জানে। এটি একটি bus master: CPU-র মতোই bus-এ ঠিকানা আর পড়া-লেখার সংকেত দেয়। কিন্তু এর কোনো program নেই; আছে শুধু কয়েকটি register: “কোথা থেকে, কোথায়, কয়টি, কোন নিয়মে”। DMA-র সাধারণ ধারণা, আর polling ও interrupt-এর সঙ্গে তুলনা, Computer Architecture কোর্সের পর্ব ৫২-এ আছে। এখানে আমরা microcontroller-এর firmware-এর দিক থেকে দেখব।
আপনি 8085/8086-এর যুগের DMA আগেই দেখেছেন: Intel 8237A, চারটি channel, HOLD আর HLDA দিয়ে CPU-র কাছ থেকে পুরো bus নিয়ে নেওয়া, word count শেষে terminal count, আর autoinitialize (পর্ব ২৭)। সেই বিবরণ এখানে আবার হবে না; শুধু পাশাপাশি রাখা যাক কী বদলেছে।
| বিষয় | 8237A (পর্ব ২৭) | STM32F103-এর DMA1 (RM0008 অধ্যায় ১৩) |
|---|---|---|
| অবস্থান | CPU-র বাইরে আলাদা ৪০ pin-এর chip | MCU-র ভেতরে, AHB-তে, CPU-র পাশে |
| Channel | ৪টি | DMA1-এ ৭টি; বড় সংস্করণে DMA2-তে আরও ৫টি |
| Bus নেওয়া | HOLD → HLDA: CPU পুরো থেমে থাকে | Bus matrix-এ round-robin; CPU চলতে থাকে, শুধু একই জায়গা চাইলে অপেক্ষা |
| ঠিকানা, গোনা | ১৬ বিট ঠিকানা, ১৬ বিট count | ৩২ বিট CPAR/CMAR, ১৬ বিট CNDTR (সর্বোচ্চ 65535) |
| বারবার একই buffer | Autoinitialize | Circular mode (CIRC বিট) |
| কাজ শেষের খবর | TC/EOP pin আর status register | HT, TC, TE ফ্ল্যাগ আর আলাদা interrupt |
| অগ্রাধিকার | নির্দিষ্ট বা ঘূর্ণায়মান | ৪ স্তর software-এ, সমান হলে ছোট channel নম্বর |
সবচেয়ে বড় পরিবর্তন bus নেওয়ার ধরনে। 8237-এর যুগে একটিই system bus, তাই DMA চলার সময় CPU পুরোপুরি থেমে থাকত। আজকের MCU-তে একটি bus matrix কয়েকটি master (CPU-র instruction ও data পথ, DMA) আর কয়েকটি slave (flash, SRAM, peripheral-এর bridge)-কে জোড়ে। CPU flash থেকে instruction আনছে আর DMA একই সময়ে ADC থেকে SRAM-এ লিখছে, দুটি আলাদা পথে, কেউ কাউকে আটকায় না। দুজন একই slave চাইলে তখনই অপেক্ষা; RM0008 (§১৩.৩) বলে, bus matrix round-robin চালায়, ফলে CPU system bus-এর অন্তত অর্ধেক bandwidth পায়। পুরোনো বইয়ের cycle stealing কথাটির আধুনিক রূপ এটিই।
ছবি ৪৬.১ — একটি MCU-তে ADC → DMA → SRAM-এর পথ
ADC request তোলে, DMA channel ১ সেবা দিয়ে acknowledge দেয়; CPU আর DMA bus matrix ভাগ করে; HT/TC আসে NVIC হয়ে
উপমা — কুলি আর রসিদের খাতা: DMA channel একজন কুলি, যার হাতে একটি চিরকুট: “৮ নম্বর প্ল্যাটফর্মের ট্রেন থেকে (CPAR) গুদামের ৩ নম্বর তাকে (CMAR) ৮টি বস্তা (CNDTR) নেবে; প্রতিটি বস্তার পরে পরের তাকে সরবে (MINC); ৪টি হলে একবার জানাবে, ৮টি হলে আবার (HT, TC); তারপর আবার প্রথম তাক থেকে (circular).” প্রতিটি নতুন ট্রেন (ADC-র নমুনা) এলে কুলি নিজেই কাজ করে; স্টেশনমাস্টার (CPU) শুধু তখন গুদামে যান, যখন অর্ধেক তাক ভরেছে।
৩ · STM32F1-এর DMA channel — চারটি register আর request-এর হাতবদল
প্রতিটি DMA channel-এর চারটি নিজস্ব register, আর পুরো DMA1-এর দুটি সাধারণ register (RM0008 §১৩.৪). DMA1-এর base ঠিকানা RM0008-এর memory map অনুযায়ী 0x40020000 (AHB-তে; নিজের chip-এর manual-এ মিলিয়ে নিন)। Channel x-এর register-এর offset = নিচের মান + 20 × (x − 1), অর্থাৎ প্রতিটি channel ২০ byte পরপর।
| Register | Offset | কাজ |
|---|---|---|
DMA_ISR | 0x00 | প্রতি channel-এ ৪ বিট: GIF, TCIF, HTIF, TEIF (channel x শুরু বিট 4(x − 1)-এ); শুধু পড়া |
DMA_IFCR | 0x04 | একই বিন্যাসে 1 লিখলে ফ্ল্যাগ মোছে; CGIFx মোছে চারটিই |
DMA_CCRx | 0x08 | channel-এর নিয়ম (নিচের সারণি) |
DMA_CNDTRx | 0x0C | বাকি transfer-এর সংখ্যা, ০–৬৫৫৩৫; প্রতি transfer-এ এক কমে |
DMA_CPARx | 0x10 | peripheral-এর register-এর ঠিকানা |
DMA_CMARx | 0x14 | memory-র buffer-এর ঠিকানা |
| বিট | নাম | অর্থ |
|---|---|---|
| 14 | MEM2MEM | memory-to-memory; request ছাড়াই চলে |
| 13:12 | PL | priority: 00 low, 01 medium, 10 high, 11 very high |
| 11:10, 9:8 | MSIZE, PSIZE | memory আর peripheral-এর মাপ: 00 = 8, 01 = 16, 10 = 32 বিট |
| 7, 6 | MINC, PINC | প্রতি transfer-এর পরে memory বা peripheral-এর ঠিকানা বাড়বে কি না |
| 5 | CIRC | circular mode |
| 4 | DIR | 0 = peripheral থেকে পড়া, 1 = memory থেকে পড়া |
| 3, 2, 1 | TEIE, HTIE, TCIE | error, অর্ধেক আর সম্পূর্ণের interrupt চালু |
| 0 | EN | channel চালু |
RM0008-এর কয়েকটি নিয়ম মাথায় রাখুন, কারণ এগুলো ভুলেই বেশিরভাগ DMA-র bug হয়। CNDTR, CPAR আর CMAR লেখা যায় শুধু channel বন্ধ (EN = 0) থাকলে। CNDTR শূন্য হলে channel চালু থাকলেও কোনো transfer হয় না (§১৩.৪.৪)। প্রতিটি peripheral নির্দিষ্ট channel-এ বাঁধা: DMA1-এ ADC1 → channel ১, USART1_TX → channel ৪, USART1_RX → channel ৫, USART2_RX → channel ৬ (সারণি ৭৮)। আর STM32F1-এ শুধু ADC1 (আর বড় সংস্করণে ADC3) DMA request তুলতে পারে; ADC2 পারে না (RM0008 §১১.১২.৩, ADC_CR2-এর DMA বিট ৮-এর বর্ণনা)।
এবার একটি transfer ভেতর থেকে দেখা যাক। RM0008 §১৩.৩.১ একটি DMA request-এর হাতবদল এভাবে বলে: একটি ঘটনার পরে peripheral DMA controller-এ request পাঠায়; controller channel-এর priority অনুযায়ী সেবা দেয়; DMA যেই peripheral-এ access করে, acknowledge পাঠায়; acknowledge পেয়ে peripheral request নামায়; request নামলে DMA acknowledge ছেড়ে দেয়। আর প্রতিটি transfer-এ তিনটি কাজ: উৎস থেকে পড়া, গন্তব্যে লেখা, আর CNDTR এক কমানো। নিচের stepper ADC1-এর একটি নমুনা ধরে এই চক্র দেখায়; সঙ্গে channel ৪ (UART-এর TX, low priority) একই সময়ে request তুলেছে।
| ADC1 request | |
| ch4 request | |
| Arbiter | |
| Bus | |
| DMA ack | |
| CNDTR1 |
- শান্ত অবস্থা। Channel ১ সাজানো: CPAR = 0x4001244C (ADC1-এর DR), CMAR = 0x20000100, CNDTR = 8, EN = 1. কেউ request তোলেনি; bus শুধু CPU-র।
- দুটি request একসাথে। ADC1-এর রূপান্তর শেষ (EOC) আর ADC_CR2-এর DMA বিট 1, তাই সে channel ১-এ request তোলে। ঠিক একই সময়ে USART1 জানায় তার পাঠানোর register খালি, channel ৪-এ request.
- Arbiter আর পড়া। Channel ১-এর PL = high, ৪-এর low; ১ জেতে (সমান হলে ছোট নম্বর জিতত)। DMA ADC1-এর DR পড়ে, আর সেই access-এর সঙ্গে ADC-কে acknowledge পাঠায়।
- লেখা আর গোনা। Acknowledge পেয়ে ADC request নামায়। DMA পড়া মানটি CMAR-এর বর্তমান ঠিকানা 0x20000100-এ লেখে; MINC থাকায় পরের ঠিকানা 0x20000102 (১৬ বিট); CNDTR 8 থেকে 7.
- হাতবদল শেষ। Request নেমে গেছে দেখে DMA acknowledge ছাড়ে। এই পুরো সময়ে CPU একটিও নির্দেশ চালায়নি; যদি সে SRAM-এর ঠিক ওই অংশ চাইত, bus matrix-এ একটি পালার অপেক্ষা করত।
- পরের পালা। এবার শুধু channel ৪-এর request বাকি, তাই arbiter তাকে নেয়: DIR = 1, memory থেকে পড়ে USART1-এর DR-এ লেখে। ADC-র পরের নমুনা এলে আবার একই চক্র; CNDTR শূন্যে পৌঁছালে TC.
৪ · Peripheral থেকে memory — circular mode আর HT/TC interrupt
বোর্ডে DMA নেই, তাই আমি একটি ছোট Python মডেল বানিয়েছি, dma_f1.py; এটি এই পাতায় লুকোনো ফাইল হিসেবে আছে, আর নিচের তিনটি block সেটি import করে। মডেলে আছে channel-এর চারটি register, ISR আর IFCR-এর ফ্ল্যাগ, circular reload, HT/TC/TE, ঠিকানা বাড়ানো, memory-to-memory, আর priority অনুযায়ী arbiter. নেই: আসল clock-এর সময়, bus matrix-এর অপেক্ষা, আর PSIZE ≠ MSIZE হলে RM0008 §১৩.৩.৪-এর alignment-এর নিয়ম। প্রতিটি transfer-এ মডেল দুটি “bus access” গোনে, একটি পড়া, একটি লেখা; এটি শেখার একক, কোনো chip-এর cycle নয়। মডেলটি আমার lab-এ একই code চালিয়ে যাচাই করা।
Circular mode-এ CNDTR শূন্যে পৌঁছালে নিজে থেকেই শুরুর মান ফিরে পায়, আর ভেতরের ঠিকানাও CPAR/CMAR-এর মানে ফেরে (RM0008 §১৩.৩.৩)। অর্থাৎ hardware নিজেই একটি ring buffer চালায়, যার শেষ ঘরের পরে আবার প্রথম ঘর। সঙ্গে দুটি interrupt: অর্ধেক transfer শেষে half-transfer (HT), আর পুরোটা শেষে transfer-complete (TC). RM0008-এর ভাষায়, অর্ধেক data transfer হলে HTIF ওঠে, আর শেষে TCIF. বিজোড় CNDTR-এ HT ঠিক কোন transfer-এর পরে ওঠে, সেটি manual-এ স্পষ্ট নয়, তাই এই পর্বে সব buffer-এর মাপ জোড়, আর বাস্তবেও জোড় রাখাই নিরাপদ।
নিচের block smart scale-এর load cell-কে ADC1 → DMA1 channel ১-এ জোড়ে: ৮টি half-word-এর buffer, circular, HT আর TC চালু। প্রথম ৪ ms খালি পাল্লা, পরের ৪ ms 150 g, তারপর 1400 g; raw মান README-র load-cell মডেল থেকে (raw = 400 + 0.7 × g). HT বা TC এলে একটি ছোট “ISR” সেই অর্ধেকের গড় নিয়ে গ্রামে বদলায় (README-র calibration: g = (raw − 400) × 2000 ÷ 1400).
from dma_f1 import *
# ADC1 → DMA1 channel 1 (RM0008 সারণি ৭৮), circular, ৮টি half-word-এর buffer
grams = [0] * 4 + [150] * 4 + [1400] * 4 # load cell-এর ওপর মাল
raws = iter(round(400 + 0.7 * g) for g in grams) # README: raw = 400 + 0.7 × g
bus, ADC1_DR, BUF = Bus(), 0x4001244C, 0x20000100
bus.dev[ADC1_DR] = lambda: next(raws)
for i in range(8): bus.mem[BUF + 2 * i] = 0
dma = DMA(bus)
dma.write(1, "CPAR", ADC1_DR); dma.write(1, "CMAR", BUF); dma.write(1, "CNDTR", 8)
ccr = PL(2) | MSIZE(16) | PSIZE(16) | MINC | CIRC | HTIE | TCIE | EN
dma.write(1, "CCR", ccr)
print(f"CCR = 0x{ccr:04X} = {ccr:015b}b")
def to_g(raw): return round((raw - 400) * 2000 / 1400)
def irq_handler(kind): # HT: প্রথম অর্ধেক তৈরি, TC: দ্বিতীয়
half = 0 if kind == "HT" else 4
vals = [bus.mem[BUF + 2 * (half + i)] for i in range(4)]
avg = (sum(vals) + 2) // 4
dma.IFCR(0b0001) # CGIF1: channel 1-এর সব ফ্ল্যাগ মোছা
return f"{kind}: buf[{half}..{half + 3}] avg={avg} -> {to_g(avg)} g"
for k in range(12): # প্রতি 1 ms-এ ADC একটি request তোলে
dma.ch[1]["req"] = True
dma.step()
isr = dma.ISR # ফ্ল্যাগ, handler মোছার আগে
note = irq_handler(dma.irq_log.pop()[1]) if dma.irq_log else ""
print(f"s{k:02d} raw={bus.mem[BUF + 2 * (k % 8)]:4} CNDTR={dma.ch[1]['CNDTR']}"
f" ISR=0x{isr:X} {note}")
print(f"12 transfers -> bus accesses = {bus.accesses}, CPU copy instructions = 0")আসল আউটপুট (ব্রাউজারের Python):
CCR = 0x25A7 = 010010110100111b
s00 raw= 400 CNDTR=7 ISR=0x0
s01 raw= 400 CNDTR=6 ISR=0x0
s02 raw= 400 CNDTR=5 ISR=0x0
s03 raw= 400 CNDTR=4 ISR=0x5 HT: buf[0..3] avg=400 -> 0 g
s04 raw= 505 CNDTR=3 ISR=0x0
s05 raw= 505 CNDTR=2 ISR=0x0
s06 raw= 505 CNDTR=1 ISR=0x0
s07 raw= 505 CNDTR=8 ISR=0x3 TC: buf[4..7] avg=505 -> 150 g
s08 raw=1380 CNDTR=7 ISR=0x0
s09 raw=1380 CNDTR=6 ISR=0x0
s10 raw=1380 CNDTR=5 ISR=0x0
s11 raw=1380 CNDTR=4 ISR=0x5 HT: buf[0..3] avg=1380 -> 1400 g
12 transfers -> bus accesses = 24, CPU copy instructions = 0
CCR = 0x25A7: ডান থেকে পড়ুন, EN (বিট ০), TCIE (১), HTIE (২), CIRC (৫), MINC (৭), PSIZE = 01 (বিট ৮, ১৬ বিট), MSIZE = 01 (বিট ১০), PL = 10 (বিট ১৩, high). DIR আর PINC 0: peripheral থেকে পড়া, ADC-র DR-এর ঠিকানা স্থির। চতুর্থ নমুনার পরে CNDTR = 4 = ৮-এর অর্ধেক, তাই ISR = 0x5 = GIF1 (বিট ০) + HTIF1 (বিট ২); অষ্টম নমুনায় ISR = 0x3 = GIF1 + TCIF1, আর CNDTR শূন্যে নেমেই আবার 8: circular reload. শেষ লাইনে HT আবার ঘর ০–৩-এ এসেছে, পুরোনো 400-এর ওপর এখন 1380. বারোটি নমুনায় CPU একটিও কপির নির্দেশ চালায়নি; দুটি ছোট handler শুধু গড় নিয়েছে।
| মুহূর্ত | |
| buf[0..3] | |
| buf[4..7] | |
| CNDTR | |
| ISR (ch1) | |
| CPU |
- সাজানো। CPAR = 0x4001244C, CMAR = 0x20000100, CNDTR = 8, তারপর CCR = 0x25A7 (EN শেষে, কারণ EN = 1 হলে বাকি তিনটি আর লেখা যায় না)। Buffer শূন্য।
- প্রথম নমুনা। ADC request তোলে, DMA 400 এনে buf[0]-এ রাখে, CMAR-এর ভেতরের ঠিকানা ২ byte এগোয়, CNDTR = 7. কোনো ফ্ল্যাগ নেই, CPU-র কিছু জানার দরকারও নেই।
- অর্ধেক পূর্ণ। চতুর্থ transfer-এর পরে CNDTR = 4 = ৮ ÷ ২: HTIF1 আর GIF1 ওঠে (ISR = 0x5), HTIE চালু তাই interrupt. Handler buf[0..3]-এর গড় নেয়: 400 → 0 g, তারপর IFCR-এ CGIF1 লিখে ফ্ল্যাগ মোছে।
- দ্বিতীয় অর্ধেক ভরছে। 150 g-এর থালা এসেছে; DMA buf[4], [5], [6]-এ 505 লিখছে, CNDTR = 1. CPU এই সময় চাইলে প্রথম অর্ধেক নিয়ে যত খুশি হিসাব করতে পারে, কারণ DMA এখন অন্য অর্ধেকে।
- সম্পূর্ণ আর reload. অষ্টম transfer-এ CNDTR = 0: TCIF1 ওঠে (ISR = 0x3), আর CIRC থাকায় CNDTR আবার 8, ঠিকানা আবার 0x20000100. Handler buf[4..7]-এর গড় নেয়: 505 → 150 g.
- আবার প্রথম অর্ধেক। 1400 g; DMA পুরোনো 400-গুলোর ওপর 1380 লিখেছে, বারোতম transfer-এ CNDTR = 4, আবার HT: গড় 1380 → 1400 g. পুরোনো data-র ওপর নতুন লেখা circular-এর স্বভাব; CPU সময়মতো না পড়লে সেটিই data হারানো।
৫ · Double buffering — ping-pong আর তার সময়ের শর্ত
ওপরের ধরনটির নাম double buffering, বা ping-pong: টেবিল টেনিসের বলের মতো কাজ দুই অর্ধেকের মধ্যে আসা-যাওয়া করে। বিয়েবাড়ির রান্নার উপমায়, দুটি বড় হাঁড়ি: একটিতে বাবুর্চি নতুন ভাত বসান (DMA ভরে), অন্যটি থেকে পরিবেশনকারী থালায় তোলেন (CPU প্রক্রিয়া করে)। হাঁড়ি খালি করার আগেই যদি নতুন ভাত সেখানে ঢালা শুরু হয়, তবে গোলমাল। তাই একটি সহজ কিন্তু কঠোর শর্ত: এক অর্ধেক প্রক্রিয়া করতে যত সময় লাগে (P), তা অন্য অর্ধেক ভরতে যত সময় লাগে তার চেয়ে বেশি হতে পারবে না। N ঘরের buffer আর নমুনার সময়-ব্যবধান Ts হলে, P ≤ (N ÷ 2) × Ts.
STM32F1-এর DMA-তে আলাদা double-buffer mode নেই; circular + HT + TC দিয়েই এটি বানানো হয়। পরের অনেক পরিবারে, যেমন STM32F4-এর DMA stream-এ, আলাদা একটি double-buffer বিট আর দুটি memory ঠিকানার register আছে, যাতে দুটি আলাদা buffer-এর মধ্যে hardware নিজেই পালা বদলায় (সেই পরিবারের reference manual-এ মিলিয়ে নিন)। ধারণা একই। নিচের block মডেলে শর্তটি পরীক্ষা করে: প্রতি 1 ms-এ একটি নমুনা, ৮ ঘর, অর্থাৎ এক অর্ধেক ভরতে 4 ms; CPU-র প্রক্রিয়ার সময় P = 3, 4 আর 5 ms. CPU অর্ধেকগুলো তৈরি হওয়ার ক্রমে নেয়; কোনো অর্ধেক তৈরি হওয়া থেকে তার প্রক্রিয়া শেষ হওয়ার আগে DMA যদি সেখানে আবার লেখে, সেটি “মুছে যাওয়া নমুনা”।
from dma_f1 import *
# Double buffering (ping-pong): DMA একটি অর্ধেক ভরে, CPU তখন অন্যটি প্রক্রিয়া করে।
# t ms-এ নমুনা t আসে; buffer ৮ ঘর = দুটি অর্ধেক × ৪; CPU একটি অর্ধেকে P ms নেয়।
def run(P, ms=32):
bus, BUF = Bus(), 0x20000200
bus.dev[0x4001244C] = lambda: 0
for i in range(8): bus.mem[BUF + 2 * i] = 0
dma = DMA(bus)
dma.write(1, "CPAR", 0x4001244C); dma.write(1, "CMAR", BUF); dma.write(1, "CNDTR", 8)
dma.write(1, "CCR", PSIZE(16) | MSIZE(16) | MINC | CIRC | HTIE | TCIE | EN)
writes, ready = [], []
for t in range(ms):
writes.append((t, (8 - dma.ch[1]["CNDTR"]) // 4)) # এই ms-এ DMA কোন অর্ধেকে লেখে
dma.ch[1]["req"] = True; dma.step()
for n, kind in dma.irq_log: # HT: অর্ধেক 0 তৈরি, TC: অর্ধেক 1
ready.append((t, 0 if kind == "HT" else 1))
dma.irq_log.clear(); dma.IFCR(0b0001)
free, bad, lag = 0, 0, 0
for tr, h in ready: # CPU অর্ধেকগুলো ক্রমে প্রক্রিয়া করে
start = max(tr, free); end = start + P; free = end
lag = max(lag, end - tr)
bad += sum(1 for tw, hw in writes if hw == h and tr < tw < end)
return len(ready), lag, bad
for P in (3, 4, 5):
n, lag, bad = run(P)
print(f"P = {P} ms: halves = {n}, worst ready->done = {lag} ms, overwritten samples = {bad}")
print("a half fills in 4 x 1 ms = 4 ms, so P must be <= 4 ms")আসল আউটপুট (ব্রাউজারের Python):
P = 3 ms: halves = 8, worst ready->done = 3 ms, overwritten samples = 0
P = 4 ms: halves = 8, worst ready->done = 4 ms, overwritten samples = 0
P = 5 ms: halves = 8, worst ready->done = 12 ms, overwritten samples = 14
a half fills in 4 x 1 ms = 4 ms, so P must be <= 4 ms
P = 3 আর 4 ms-এ প্রতিটি অর্ধেক তৈরি হওয়ার 3 বা 4 ms-এর মধ্যে শেষ, কোনো নমুনা মোছেনি। P = 5 ms-এ শুধু 1 ms বেশি, কিন্তু ফল নাটকীয়: প্রতি পালায় CPU আরও 1 ms পিছিয়ে পড়ে, সবচেয়ে খারাপ দেরি 12 ms, আর 32 ms-এ ১৪টি নমুনা প্রক্রিয়ার আগেই মুছে গেছে। দেরি জমতে থাকে, কখনো ফেরে না। P = 4 ms ঠিক সীমায়; আসল firmware-এ interrupt-এর latency আর অন্য ISR-এর জন্য জায়গা রাখতে P সীমার বেশ নিচে রাখুন।
| সময় | |
| DMA লিখছে | |
| P = 4: CPU | |
| P = 5: CPU |
- প্রথম HT. 3 ms-এর নমুনার পরে অর্ধেক A তৈরি। দুই ক্ষেত্রেই CPU সঙ্গে সঙ্গে A ধরে; DMA এখন B-তে লিখবে (4–7 ms).
- প্রথম TC. 7 ms-এ B তৈরি। P = 4 হলে CPU ঠিক 7 ms-এ A শেষ করে B ধরে। P = 5 হলে CPU এখনো A-তে (8 ms পর্যন্ত); B-কে অপেক্ষা করতে হয়।
- DMA আবার A-তে। 8 ms-এর নমুনা যায় ঘর ০-এ। P = 4: A তো 7 ms-এই শেষ, সমস্যা নেই। P = 5: A ঠিক 8 ms-এ শেষ হলো, অল্পের জন্য বাঁচল; B শুরু হলো 8 ms-এ, শেষ হবে 13 ms-এ।
- দ্বিতীয় HT. 11 ms-এ A আবার তৈরি। P = 4: B 11 ms-এ শেষ, CPU A ধরে। P = 5: CPU এখনো B-তে, A-কে লাইনে দাঁড়াতে হয়।
- প্রথম সংঘর্ষ। 12 ms-এর নমুনা DMA লেখে B-এর ঘর ৪-এ, অথচ P = 5-এ CPU 13 ms পর্যন্ত B পড়ছে: B-এর একটি নমুনা প্রক্রিয়ার মাঝেই বদলে গেল। CPU-র কাছে কোনো সংকেত আসে না; শুধু হিসাব ভুল।
- দীর্ঘ মেয়াদে। P = 4-এ প্রতিটি অর্ধেক 4 ms-এর মধ্যে শেষ, ৩২ ms-এ ০টি নমুনা মোছা। P = 5-এ দেরি প্রতি পালায় 1 ms করে বাড়ে, সবচেয়ে খারাপ 12 ms, মোট ১৪টি নমুনা মুছে গেছে। সমাধান: P কমানো, buffer বড় করা, বা নমুনার হার কমানো।
বাস্তবে সংঘর্ষ ধরার একটি সহজ কৌশল: HT বা TC-এর handler-এর শুরুতে আর শেষে CNDTR পড়ুন। HT-এর handler-এর শেষে CNDTR যদি N ÷ 2-এর নিচে নেমে না গিয়ে আবার N-এর কাছে ফিরে আসে, অর্থাৎ DMA পুরো এক পাক ঘুরে প্রথম অর্ধেকে ঢুকে পড়েছে, তবে overrun ঘটেছে। আরেকটি পথ: TC আর HT দুটো ফ্ল্যাগ একসাথে 1 পাওয়া মানে একটি interrupt ধরা পড়েনি। Audio বা মাপের যন্ত্রে একটি “overrun counter” রাখা ভালো অভ্যাস, যাতে মাঠে কী ঘটছে তা telemetry-তে দেখা যায় (পর্ব ৭৫)।
৬ · Memory-to-memory, priority আর transfer error
MEM2MEM বিট 1 হলে channel কোনো peripheral-এর request-এর অপেক্ষা করে না; EN দেওয়ামাত্র কপি শুরু, আর CNDTR শূন্যে পৌঁছালে থামে। RM0008-এর একটি স্পষ্ট নিষেধ: memory-to-memory আর circular mode একসাথে চলবে না (§১৩.৩.৩)। এখানে “peripheral” ঠিকানাটি (CPAR) উৎস, আর PINC দিয়ে সেটিও বাড়াতে হয়। 8237-এর memory-to-memory DMA-তে channel ০ আর ১ মিলে কাজটি করত (পর্ব ২৭); এখানে একটি channel-ই যথেষ্ট।
Priority-র নিয়ম দুই স্তরের (RM0008 §১৩.৩.২): আগে CCR-এর PL, চারটি স্তর; সমান হলে ছোট channel নম্বর জেতে। নিচের block চারটি channel একসাথে চালায়: ১ = ADC1 (high, দুটি নমুনা), ৪ = USART1_TX (low), আর ২ ও ৩ = memory-to-memory (দুটোই medium). তারপর একটি ৬৪ word-এর কপি, আর শেষে ইচ্ছে করে ভুল CMAR দিয়ে একটি transfer error. মডেলে অজানা ঠিকানা মানে bus error; আসল chip-এ কোন ঠিকানা bus error দেয় তা memory map-এর ওপর নির্ভর করে।
from dma_f1 import *
bus = Bus()
for a in range(0x20000000, 0x20000400, 4): bus.mem[a] = a & 0xFF # ১ KiB SRAM
bus.dev[0x4001244C] = lambda: 505 # ADC1->DR
bus.mem[0x40013804] = 0 # USART1->DR (লেখার জন্য)
dma = DMA(bus)
def setup(n, par, mar, cnt, ccr):
dma.write(n, "CPAR", par); dma.write(n, "CMAR", mar); dma.write(n, "CNDTR", cnt)
dma.write(n, "CCR", ccr | EN)
# ch1 ADC1 (high), ch4 USART1_TX (low), ch2 আর ch3: memory-to-memory (দুটোই medium)
setup(1, 0x4001244C, 0x20000300, 2, PL(2) | PSIZE(16) | MSIZE(16) | MINC)
setup(4, 0x40013804, 0x20000000, 2, PL(0) | DIR | PSIZE(8) | MSIZE(8) | MINC)
setup(2, 0x20000000, 0x20000100, 3, PL(1) | MEM2MEM | PINC | MINC | PSIZE(32) | MSIZE(32))
setup(3, 0x20000010, 0x20000200, 2, PL(1) | MEM2MEM | PINC | MINC | PSIZE(32) | MSIZE(32))
dma.ch[1]["req"] = dma.ch[4]["req"] = True # ADC আর UART একসাথে চাইল
order = []
while (n := dma.step()) is not None:
order.append(n)
if len(order) == 3: dma.ch[1]["req"] = True # ADC-র পরের নমুনা মাঝপথে
print("service order:", order)
print("bus accesses:", bus.accesses, "for", len(order), "transfers")
# memory-to-memory 256 byte = 64 word, তারপর একটি ভুল ঠিকানা
dma2 = DMA(bus); dma, before = dma2, bus.accesses
setup(1, 0x20000000, 0x20000100, 64, MEM2MEM | PINC | MINC | PSIZE(32) | MSIZE(32))
while dma.step(): pass
print("64-word copy: bus accesses =", bus.accesses - before,
"| copy ok:", all(bus.mem[0x20000100 + 4 * i] == bus.mem[0x20000000 + 4 * i] for i in range(64)))
setup(2, 0x20000000, 0x60000000, 4, MEM2MEM | PINC | MINC | PSIZE(32) | MSIZE(32) | TEIE)
dma.step()
print(f"bad CMAR: ISR=0x{dma.ISR:08X} EN={dma.ch[2]['CCR'] & EN} CNDTR={dma.ch[2]['CNDTR']} irq={dma.irq_log}")আসল আউটপুট (ব্রাউজারের Python):
service order: [1, 2, 2, 1, 2, 3, 3, 4]
bus accesses: 16 for 8 transfers
64-word copy: bus accesses = 128 | copy ok: True
bad CMAR: ISR=0x00000097 EN=0 CNDTR=4 irq=[(2, 'TE')]
ক্রমটি পড়ুন: প্রথমে ১ (high), তারপর ২ আর ৩ দুজনেই medium, ছোট নম্বর ২ জেতে। তৃতীয় transfer-এর পরে ADC আবার request তোলে, আর high বলে সঙ্গে সঙ্গে ১ ঢুকে পড়ে, ২-এর কাজের মাঝখানে। ৩ পায় ২ শেষ হওয়ার পরে, আর low-priority-র UART (৪) সবার শেষে। এই মডেলে প্রতিটি transfer-এর পরে arbiter আবার বাছাই করে; STM32F1-এর DMA-তে burst বা FIFO নেই, তাই আমার পড়ায় এটিই manual-এর আচরণ, তবে সূক্ষ্ম সময়ের জন্য RM0008 আর ST-এর DMA application note মিলিয়ে নিন। দ্বিতীয় লাইন: ৬৪ word কপিতে 128 bus access, প্রতিটিতে একটি পড়া আর একটি লেখা। শেষ লাইনে ISR = 0x97: channel ১-এর চারটি বিটে 0x7 (GIF, TCIF, HTIF; কপিটির ফ্ল্যাগ, interrupt বন্ধ ছিল বলে শুধু ফ্ল্যাগ), channel ২-এর বিটে 0x9 = GIF + TEIF. Hardware EN মুছে channel বন্ধ করেছে (EN = 0), CNDTR 4-ই রয়ে গেছে: একটিও transfer হয়নি।
CPU দিয়ে একই কপি — board-এ আসল গোনা
তুলনার জন্য একই 256 byte এবার CPU দিয়ে, কোর্সের board-এ। cpu_copy.c SysTick-কে বাধাহীন চালায় (LOAD = 0xFFFFFF, interrupt ছাড়া) আর কপির আগে-পরে VAL পড়ে; board-এ ১টি নির্দেশ = ১ cycle (Spec decision 17), তাই পার্থক্যটি আসলে কয়টি নির্দেশ চলল তার গোনা। একটি byte-এর loop আর একটি word-এর loop, দুটোই while (n--) *d++ = *s++;, শুধু pointer-এর type আলাদা। 8086-এর REP MOVSB একটি নির্দেশেই এই কাজ করত (পর্ব ১৯); Cortex-M3-এ তেমন নির্দেশ নেই, compiler loop বানায়।
সত্যিকারের run · Clang 22.1.8 (ziglang 0.17.1), Unicorn 2.1.4, বাজারঘর board BG-M3
$ python -B board.py run ~/lab/build/cpu_copy.elf
[ 0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[ 0.2147 ms] UART: measure overhead : 1 cycles
[ 0.3342 ms] UART: copy 256 B byte-wise : 658 cycles
[ 0.3937 ms] UART: copy 256 B word-wise : 178 cycles
[ 0.5820 ms] UART: mismatches = 0
[ 0.5829 ms] exit(0) after 4663 cycles
Clang (-O2) byte-এর loop-টিকে চারবার খুলে লিখেছে (unroll). clang -S --target=thumbv7m-none-eabi -mcpu=cortex-m3 -O2-এর ভেতরের loop:
.LBB0_9: @ প্রতি পাকে ৪ byte
ldrb r2, [r1, #4]!
subs r3, #4
strb r2, [r0, #4]!
ldrb r2, [r1, #1]
strb r2, [r0, #1]
ldrb r2, [r1, #2]
strb r2, [r0, #2]
ldrb r2, [r1, #3]
strb r2, [r0, #3]
bne .LBB0_9
প্রতি পাকে ১০টি নির্দেশে ৪ byte; ৬৪ পাকে 640, সঙ্গে শুরুর প্রস্তুতি মিলে 658. Word-এর loop-এ একই গঠনে ৪টি word প্রতি পাকে, ১৬ পাকে 160 + প্রস্তুতি = 178. অর্থাৎ board-এ word-এর কপি প্রতি byte-এ প্রায় 0.7 নির্দেশ। আসল Cortex-M3-এ load আর store-এর cycle বেশি লাগে, flash-এর wait state থাকে, তাই সত্যিকারের সময় chip-এর datasheet আর মাপ থেকেই আসবে; এখানে তুলনাটি নীতির, সংখ্যার নয়।
৭ · DMA বনাম CPU — কোথায় লাভ, কোথায় নয়
একটি প্রচলিত ভুল ধারণা: “DMA দিয়ে কপি সবসময় দ্রুত।” মডেলের ৬৪ word-এর কপিতে 128টি bus access; board-এ CPU-র কপিতে 178টি নির্দেশ, যার মধ্যে ১২৮টিই আসলে load বা store, বাকিগুলো গোনা আর লাফ। দুজনকেই একই bus দিয়ে একই ১২৮টি access করতে হয়, আর bus একবারে একজনকেই সেবা দেয়। তাই বড় কপিতে DMA কিছুটা কম ঝামেলায় কাজ সারতে পারে, কিন্তু অলৌকিক গতি আনে না। আসল লাভ তিনটি জায়গায়:
- CPU মুক্ত থাকে। DMA কপি করার সময় CPU অন্য কাজ করতে পারে, বা WFI-তে ঘুমিয়ে শক্তি বাঁচাতে পারে (পর্ব ৬০)। কোনো নমুনার জন্য তাকে জাগতে হয় না, শুধু HT/TC-তে।
- সময়ের নিয়মিততা। Peripheral request দেওয়ামাত্র সেবা পায়, CPU-র critical section বা অন্য ISR-এর ওপর নির্ভর না করে। অংশ ১-এর নমুনা যদি একটি hardware timer (পর্ব ৪৪) ADC-কে চালু করত আর DMA ফল তুলে নিত, তবে তিনটি নমুনা হারাত না, কারণ timer, ADC আর DMA-র request কেউই CPU-র PRIMASK মানে না।
- উচ্চ হারের data. নমুনার হার বাড়লে CPU-র খরচ সমানুপাতিক বাড়ে, আর DMA-র ক্ষেত্রে CPU-র খরচ শুধু প্রতি অর্ধেক buffer-এ একটি interrupt. 400 kHz-এ board-এর 20 cycle-এর ISR পুরো CPU খেয়ে ফেলত; DMA-তে ৮ ঘরের buffer হলে একই সময়ে interrupt আসে চার নমুনায় একবার, buffer ১০২৪ ঘরের হলে ৫১২ নমুনায় একবার।
| নমুনার হার | CPU দিয়ে (20 cycle × হার ÷ 8 MHz) | DMA দিয়ে CPU-কে কখন জাগতে হয় |
|---|---|---|
| 1 kHz | 0.25% | প্রতি HT/TC, অর্থাৎ N ÷ 2 নমুনায় একবার |
| 10 kHz | 2.5% | একই |
| 100 kHz | 25% | একই |
| 400 kHz | 100% — আর কিছু চলে না | একই; সীমা তখন bus আর peripheral |
সারণির শতাংশগুলো board-এর মাপা 20 cycle থেকে সরল গুণ; আসল chip-এ প্রতি নমুনায় খরচ বেশি, তাই সীমা আরও আগে আসবে। উল্টো দিকে, কখন DMA দরকার নেই: খুব ছোট কপিতে (কয়েক byte) channel সাজানো, চালু করা আর শেষের interrupt সামলানো কপির চেয়ে বেশি কাজ; কম হারের, অনিয়মিত data-তে (যেমন cold-storage monitor-এর প্রতি সেকেন্ডে একটি I2C পড়া) সরল polling বা interrupt-ই যথেষ্ট আর debug করা সহজ। বাজারঘরের smart scale-এ 100 ms-এ চারটি রূপান্তরের জন্য DMA বিলাসিতা; কিন্তু 1 kHz-এ নমুনা নিয়ে filter চালাতে চাইলে, বা পর্ব ৪৯ (UART)-এর মতো একটি দ্রুত লাইনে লম্বা বার্তা পাঠাতে, DMA ঠিক জায়গা।
৮ · Firmware-এর নিয়ম — buffer, volatile, barrier আর cache
DMA-র bug সবচেয়ে কষ্টের, কারণ ভুলটি CPU-র কোনো নির্দেশে নয়: একটি আলাদা যন্ত্র চুপচাপ মেমরিতে লিখছে, debugger-এর breakpoint তাকে থামায় না। পাঁচটি নিয়ম বেশিরভাগ বিপদ এড়ায়।
- Buffer static বা global, কখনো stack-এ নয়। একটি function-এর ভেতরের
uint16_t buf[8];-এর ঠিকানা CMAR-এ দিয়ে function থেকে ফিরে এলে, DMA সেই stack-এর জায়গায় লিখতেই থাকে, যেখানে এখন অন্য function-এর local ভ্যারিয়েবল আর ফেরার ঠিকানা। ফল এলোমেলো crash বা HardFault, ঘটনা থেকে অনেক দূরে। Static বরাদ্দের যুক্তি পর্ব ৩৯-এ। - DMA-র লেখা buffer CPU-র কাছে volatile. Compiler জানে না যে buffer পেছন থেকে বদলায়; একটি loop-এ একই ঘর বারবার পড়লে সে মান register-এ রেখে দিতে পারে। হয় buffer
volatile, নয় HT/TC-এর পরে একটি compiler barrier; বিস্তারিত পর্ব ৩৪-এ। - লেখা শেষ, তারপর DMA চালু। CPU একটি buffer-এ বার্তা লিখে তারপর EN দিলে, লেখাগুলো যেন সত্যিই মেমরিতে পৌঁছায় তারপর DMA শুরু হয়। Cortex-M-এ এর জন্য অনেক vendor-এর driver EN-এর আগে
__DMB()রাখে, একটি memory barrier; সরল Cortex-M3-এ এটি প্রায়ই দরকার হয় না, কিন্তু রাখলে কোড অন্য core-এ নিরাপদ থাকে। - সাজানোর ক্রম: আগে DMA-র clock (STM32F1-এ RCC-র AHBENR-এ DMA1EN), তারপর channel বন্ধ অবস্থায় CPAR, CMAR, CNDTR, তারপর CCR-এর নিয়ম, সবশেষে EN; তারপরই peripheral-এর DMA বিট (ADC_CR2-এর DMA, USART-এর CR3-এ DMAR বা DMAT). উল্টো ক্রমে peripheral আগেই request তুলে ফেলতে পারে।
- বন্ধ করে বদলান। চলমান channel-এর CNDTR বা ঠিকানা বদলানো যায় না; EN = 0 করে, ফ্ল্যাগ মুছে, তারপর নতুন মান।
Cache থাকলে — Cortex-M7-এর সমস্যা
Cortex-M3 আর M4 core-এ data cache নেই, তাই STM32F1-এ DMA আর CPU একই SRAM দেখে। কিন্তু Cortex-M7-এর chip-গুলোতে (যেমন STM32F7 আর H7 পরিবার) L1 data cache আছে, আর DMA সাধারণত সেই cache দেখে না; ARM-এর Cortex-M7 Technical Reference Manual অনুযায়ী এর cache line ৩২ byte. দুটি বিপদ: CPU একটি TX buffer লিখল, মানগুলো এখনো cache-এ, মেমরিতে নয়, আর DMA মেমরি থেকে পুরোনো মান পাঠাল; অথবা DMA একটি RX buffer-এ নতুন data লিখল, কিন্তু CPU cache-এর পুরোনো কপি পড়ল। এটি cache coherence-এর সমস্যা, এখানে core আর DMA-র মধ্যে। সমাধান: DMA পড়ার আগে cache clean, DMA লেখার পরে CPU পড়ার আগে cache invalidate; buffer-এর শুরু আর আকার ৩২ byte-এর গুণিতক রাখা, যাতে invalidate পাশের ভ্যারিয়েবল মুছে না দেয়; অথবা MPU দিয়ে buffer-এর অঞ্চলকে non-cacheable করা। CMSIS-এ এর জন্য SCB_CleanDCache_by_Addr আর SCB_InvalidateDCache_by_Addr-এর মতো function আছে; নির্দিষ্ট chip-এর manual আর application note মিলিয়ে ব্যবহার করুন। Cache-এর মূল ধারণা Computer Architecture-এর পর্ব ৫৩-এ।
সাবধান — DMA সব ঠিকানায় যেতে পারে: অনেক MCU-তে Cortex-M-এর MPU শুধু CPU-র access পাহারা দেয়, DMA-র নয় (নিজের chip-এর manual দেখুন)। তাই ভুল CMAR একটি নিরাপদ মনে হওয়া memory-কেও চুপচাপ নষ্ট করতে পারে। CMAR আর CNDTR লেখার আগে buffer-এর সীমা assert দিয়ে পরীক্ষা করা, আর TEIE চালু রাখা, ভালো অভ্যাস।
আরও গভীরে: ১৯৮১ সালের IBM PC-তে 8237-এর একটি channel প্রচলিত বিবরণ অনুযায়ী DRAM refresh-এর কাজে লাগানো হয়েছিল, আর floppy disk-এর data-ও DMA দিয়ে যেত; সেখানে DMA ছিল একটি সাধারণ “সময়মতো কাজ”-এর যন্ত্র। আজকের PC-তে PCIe-র যন্ত্রগুলো নিজেই bus master হয়ে মেমরিতে লেখে, আর OS একটি IOMMU দিয়ে ঠিক করে দেয় কোন যন্ত্র কোন ঠিকানায় যেতে পারবে; আর বড় SoC-তে DMA “scatter-gather” তালিকা ধরে ছড়ানো buffer থেকে data জড়ো করে। Microcontroller-এর জগতেও এই দিকটি এসেছে: অনেক নতুন MCU-তে DMA-র request কোন peripheral থেকে আসবে তা একটি আলাদা multiplexer দিয়ে বাছা যায়, আর linked-list-এর মতো descriptor দিয়ে কয়েকটি কাজ পরপর সাজানো যায়।
পরীক্ষা ও ইন্টারভিউতে: (১) “DMA কেন?” → CPU-কে data কপির কাজ থেকে মুক্তি, peripheral-কে সময়মতো সেবা, উচ্চ হারের data. (২) “Circular mode আর HT/TC দিয়ে কী হয়?” → গোনা শেষে নিজে থেকে reload, এক অর্ধেক ভরলে HT, পুরো ভরলে TC, তাই double buffering. (৩) “STM32F1-এ দুটি channel-এর priority সমান হলে কে আগে?” → ছোট channel নম্বর. (৪) “DMA buffer stack-এ রাখলে কী হয়?” → function ফেরার পরেও DMA সেখানে লেখে, stack নষ্ট. (৫) “Cortex-M7-এ DMA-তে cache-এর কী করতে হয়?” → TX-এর আগে clean, RX-এর পরে invalidate, অথবা non-cacheable অঞ্চল, buffer cache line-এ সাজানো।
৯ · AI-এর যুগে DMA-র কোড যাচাই
“STM32-এ ADC DMA circular-এর কোড দিন” লিখলে AI assistant দ্রুত কোড দেয়। কিন্তু DMA-র কোডে ভুল compile-এ ধরা পড়ে না, আর অনেক সময় প্রথম কয়েক মিনিট কাজও করে। সবচেয়ে চেনা ভুল আর ধরার উপায়:
| AI প্রায়ই যা করে | কীভাবে ধরবেন |
|---|---|
STM32F1-এর কোডে F4-এর DMA_Stream, NDTR, CHSEL বা DBM বিট মিশিয়ে দেয়; channel আর request-এর জোড়া বানিয়ে বলে | নির্দিষ্ট পরিবারের reference manual-এর DMA অধ্যায় আর request mapping-এর সারণি (F1: RM0008 সারণি ৭৮) মিলিয়ে দেখুন |
| EN চালুর পরে CNDTR বা CMAR লেখে, বা DMA-র clock চালু করতে ভোলে | সাজানোর ক্রম (clock → ঠিকানা → গোনা → CCR → EN → peripheral) তালিকা ধরে মিলিয়ে নিন |
Buffer function-এর local array; volatile বা barrier নেই | CMAR-এ কোন ভ্যারিয়েবলের ঠিকানা যাচ্ছে তা খুঁজে দেখুন, সেটি static কি না |
| HT/TC-এর handler-এ ফ্ল্যাগ মোছে না, বা পুরো IFCR-এ লিখে অন্য channel-এর ফ্ল্যাগ মুছে দেয় | IFCR-এ শুধু নিজের channel-এর বিট (বিট 4(x − 1) থেকে) লেখা হচ্ছে কি না দেখুন |
| Cortex-M7-এ cache-এর কথা বলে না, বা পুরো cache বন্ধ করে দিতে বলে | Chip-এ data cache আছে কি না জানুন; clean/invalidate, ৩২ byte সাজানো বা MPU-র অঞ্চল আছে কি না দেখুন |
| “DMA সবসময় দ্রুত” বলে দুই byte-এর কপিতেও DMA দেয় | কাজের আকার, হার আর setup-এর খরচ হিসাব করুন; ছোট কাজে সরল কোড রাখুন |
AI-কে কাজে লাগাতে chip, peripheral আর সময়ের শর্ত শুরুতেই স্পষ্ট বলুন, আর যাচাইয়ের শর্ত দিন:
AI-এর উত্তর হাতে পেলে — যাচাইয়ের চেকলিস্ট
ভাবনার প্রশ্ন
প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন, তারপর “→ উত্তর” চাপুন।
প্র ০১8237-এর যুগে DMA চলার সময় CPU পুরো থেমে থাকত (HOLD/HLDA), আর আজকের STM32-এ CPU চলতেই থাকে। এই পরিবর্তন কেন এল, আর এর লাভ ও দাম কী?
8085 আর 8086-এর যুগে একটি computer-এর ভেতরে একটিই system bus: একগুচ্ছ ঠিকানার তার, data-র তার আর পড়া-লেখার সংকেত। CPU, মেমরি আর সব I/O এই এক রাস্তায়। দুজন একসাথে রাস্তা চালালে তারে সংঘাত হয়, তাই 8237-কে bus চাইতে হতো HOLD তুলে, আর CPU চলতি machine cycle শেষ করে নিজের bus-এর তার ভাসিয়ে HLDA দিত (পর্ব ২৭)। সেই সময়টা CPU কিছুই করতে পারত না, কারণ instruction আনতেও তাকে ওই একই bus লাগত। ১৯৮১ সালের IBM PC-তে এই নকশা যথেষ্ট ছিল: floppy-র data ধীর, আর DMA-র প্রতিটি transfer CPU-র সময় অল্পই নিত।
Microcontroller-এ সবকিছু একটি chip-এর ভেতরে আসার পরে নকশাকারদের হাতে নতুন সুযোগ এল: chip-এর ভেতরের তার সস্তা, তাই একটি bus-এর বদলে কয়েকটি পথ রাখা যায়। Cortex-M3-এর core নিজেই instruction আর data-র জন্য আলাদা bus interface রাখে (ICode, DCode আর System bus), আর ST-এর STM32F1-এ একটি bus matrix এই master-গুলোকে, সঙ্গে DMA-কে, flash, SRAM আর peripheral-এর bridge-এর সঙ্গে জোড়ে। ফলে CPU flash থেকে instruction আনছে, আর DMA একই সময়ে ADC থেকে SRAM-এ লিখছে, দুটি আলাদা পথে। শুধু দুজন একই slave চাইলে arbitration; RM0008 বলে round-robin চলে আর CPU অন্তত অর্ধেক bandwidth পায়।
লাভ স্পষ্ট: DMA আর CPU সত্যিকারের সমান্তরালে কাজ করে, আর CPU-র কাজের সময় অনেক কম অনিশ্চিত হয়। দাম তিন জায়গায়। প্রথমত, সময়ের হিসাব জটিল: CPU-র একটি load-এর সময় এখন নির্ভর করে DMA ঠিক সেই মুহূর্তে SRAM চাইছে কি না, তাই কঠোর real-time কোডে worst case ধরতে হয় (পর্ব ৫৪)। দ্বিতীয়ত, silicon আর শক্তি: matrix-এর সুইচ আর arbiter জায়গা আর current নেয়। তৃতীয়ত, ঠিক করা কঠিন bug: দুটি স্বাধীন master একই মেমরিতে লিখলে, কে কখন কী দেখল, সেটি এখন আর একটি নির্দেশের ক্রম নয়। এ কারণেই ring buffer-এর মালিকানার নিয়ম (কে লেখে, কে পড়ে) আর volatile-এর মতো বিষয় DMA-র সঙ্গে আরও জরুরি হয়ে উঠেছে।
মূল উপলব্ধি: একটি bus-এর যুগে DMA মানে CPU-র কাছ থেকে রাস্তা ধার নেওয়া; chip-এর ভেতরে অনেক পথ আসায় DMA এখন CPU-র পাশে সমান্তরাল কর্মী, যার দাম জটিলতর timing আর সাবধানে ভাগ করা মেমরি।
প্র ০২এই পর্বের মডেলে ৬৪ word কপিতে DMA-র 128 bus access আর board-এ CPU-র 178 নির্দেশ এসেছে। এই দুটি সংখ্যা সরাসরি তুলনা করা কতটা ঠিক, আর আসল chip-এ “DMA না CPU” সিদ্ধান্ত কীভাবে নেবেন?
সরাসরি তুলনা ঠিক নয়, আর কেন নয় সেটি বোঝাই আসল শিক্ষা। Board-এর 178 একটি গোনা: কয়টি Thumb নির্দেশ চলল, কারণ board-এ ১ নির্দেশ = ১ cycle (Spec decision 17). আসল Cortex-M3-এ একটি load বা store-এর জন্য সাধারণত একাধিক cycle লাগে, পরপর load-store কিছুটা জোড়া লাগতে পারে, আর flash থেকে নির্দেশ আনতে wait state থাকে; তাই আসল সময় board-এর সংখ্যার চেয়ে আলাদা, আর chip ভেদে আলাদা। মডেলের 128 আরও বিমূর্ত: প্রতিটি transfer-এ একটি পড়া আর একটি লেখা, এই নীতির গোনা। আসল DMA-তে প্রতিটি transfer-এর সঙ্গে arbitration আর ঠিকানা হিসাবের নিজস্ব খরচ আছে, যার হিসাব ST তাদের DMA-র application note-এ দেয়; সেটি না দেখে কোনো cycle-সংখ্যা বলা উচিত নয়।
তবু দুটি সংখ্যার মধ্যে একটি সৎ মিল আছে: দুটি পথেই ১২৮টি মেমরি access অপরিহার্য। CPU-র ১৭৮-এর মধ্যে ১২৮টি load/store, বাকি ৫০টির মতো গোনা, তুলনা আর লাফ। DMA সেই বাড়তি “হিসাব-রাখা”-র কাজ hardware-এ করে, কিন্তু মেমরির কাজ কমাতে পারে না। তাই বড় কপিতে DMA সমান বা কিছুটা ভালো হতে পারে, কিন্তু গতির জন্য একে বেছে নেওয়ার যুক্তি দুর্বল।
আসল chip-এ সিদ্ধান্ত নেওয়ার পথ চারটি প্রশ্ন। এক, কাজের সময় CPU-র কি অন্য জরুরি কাজ বা ঘুমানোর সুযোগ আছে? থাকলে DMA. দুই, data কি peripheral-এর তালে নিয়মিত আসে, আর একটি নমুনা হারানো কি ক্ষতিকর? হলে DMA, কারণ এটি critical section মানে না (অংশ ১). তিন, কাজ কত বড়? কয়েক byte-এর জন্য channel সাজানো আর interrupt সামলানো কপির চেয়ে বেশি। চার, মেপে দেখেছেন কি? সবচেয়ে ভালো উত্তর আসে আসল board-এ একটি GPIO pin উঁচু-নিচু করে oscilloscope-এ সময় মাপা, বা Cortex-M3/M4-এর DWT cycle counter পড়ে; অনুমান বা AI-এর বলা সংখ্যা নয়।
মূল উপলব্ধি: DMA মেমরির কাজ কমায় না, শুধু কে করবে তা বদলায়; সিদ্ধান্তের ভিত্তি CPU-র স্বাধীনতা, সময়ের নিয়মিততা আর কাজের আকার, আর সংখ্যা আসবে আসল hardware-এর মাপ থেকে, মডেল বা emulator থেকে নয়।
প্র ০৩Circular DMA-তে CPU সময়মতো না পড়লে পুরোনো data চুপচাপ মুছে যায়, কোনো error আসে না। একটি মাপের যন্ত্রে বা audio-তে এটি কেন বিপজ্জনক, আর firmware কীভাবে overrun ধরতে ও সামলাতে পারে?
Circular mode-এর পুরো নকশাই এই ধারণার ওপর: DMA কখনো থামে না, কারণ peripheral-এর তাল থামানো যায় না। ADC প্রতি 1 ms-এ একটি নমুনা দেবেই; DMA যদি “জায়গা নেই” বলে থেমে যেত, তাহলে নতুন নমুনা হারাত। তাই hardware বেছে নিয়েছে পুরোনো data-র ওপর লিখে যাওয়া। ফলাফল: overrun-এ কোনো ফ্ল্যাগ ওঠে না, TE আসে না, শুধু একটি অর্ধেক প্রক্রিয়ার মাঝেই বদলে যায়। ping-pong-এর মডেলে P = 5 ms-এ ঠিক এটিই দেখা গেছে: ৩২ ms-এ ১৪টি নমুনা মুছে গেল, আর CPU-র কাছে কোনো সংকেত গেল না।
বিপদ ক্ষেত্রভেদে ভিন্ন। Audio-তে মুছে যাওয়া নমুনা একটি “ক্লিক” বা কাঁপুনি হয়ে কানে আসে, তাই অন্তত টের পাওয়া যায়। মাপের যন্ত্রে বিপদ বেশি, কারণ ভুলটি নিঃশব্দ: smart scale-এর গড়ে দুটি নমুনা পরের মুহূর্তের, ফলে ওজন একটু অন্য, দামও একটু অন্য। ধীরে ধীরে মাল তোলার সময় এই ভুল হয়তো কয়েক গ্রাম, যা কেউ ধরবে না, অথচ হিসাবটি আর নির্ভরযোগ্য নয়। শিল্প-নিয়ন্ত্রণে (পর্ব ৬৯-এর PID) পুরোনো আর নতুন নমুনা মিশে গেলে derivative-এর হিসাবে বড় লাফ আসতে পারে।
ধরার কৌশল কয়েকটি। এক, handler-এর শেষে CNDTR পড়া: HT-এর handler শেষ হওয়ার মুহূর্তে CNDTR যদি এখনো N ÷ 2-এর নিচে থাকে, অর্থাৎ DMA দ্বিতীয় অর্ধেকেই আছে, তবে নিরাপদ; যদি N-এর কাছে ফিরে এসে থাকে, DMA প্রথম অর্ধেকে ঢুকে পড়েছে। দুই, একটি interrupt-এ HTIF আর TCIF দুটোই 1 পাওয়া মানে একটি ঘটনা সময়মতো সেবা পায়নি। তিন, সময়ের ছাপ: প্রতিটি HT/TC-এ একটি timer-এর মান রেখে পরপর দুটির ব্যবধান মেলানো। ধরা পড়লে কী করবেন, তা নকশার সিদ্ধান্ত: একটি overrun counter বাড়ানো, সেই অর্ধেকের ফল বাতিল করা, filter-কে আবার শুরু করা, আর telemetry-তে জানানো (পর্ব ৭৫)। দীর্ঘ মেয়াদে সমাধান buffer বড় করা বা প্রক্রিয়া হালকা করা, যাতে P সীমার যথেষ্ট নিচে থাকে।
মূল উপলব্ধি: Circular DMA ইচ্ছে করেই থামে না আর অভিযোগ করে না; তাই overrun ধরার দায় firmware-এর, CNDTR, ফ্ল্যাগের জোড়া আর সময়ের ছাপ দিয়ে, আর সমাধান হিসাব করা margin.
প্র ০৪STM32F1-এ DMA আর CPU সবসময় একই data দেখে, কিন্তু Cortex-M7-এর chip-এ data cache আসার পরে DMA-র কোডে clean আর invalidate লাগে। PC-তে সাধারণত এই ঝামেলা কম কেন, আর microcontroller-এ সঠিক নকশা কী?
Cache হলো CPU-র পাশের ছোট দ্রুত মেমরি, যেখানে সাম্প্রতিক data-র কপি থাকে (Computer Architecture-এর cache-এর পর্বগুলো)। সমস্যা তখনই, যখন একই ঠিকানার দুটি কপি আলাদা হয়ে যায়। Cortex-M3/M4-এর core-এ data cache নেই, তাই STM32F1-এ CPU যা লেখে তা সরাসরি SRAM-এ যায় (core-এর ছোট write buffer-এর কথা আলাদা), আর DMA ঠিক সেটিই দেখে। Cortex-M7 দ্রুত চলে, তাই তার ধীর মেমরির সামনে একটি L1 data cache দরকার হয়েছে। এই cache CPU-র, DMA-র নয়: ST-এর STM32F7 বা H7-এর মতো chip-এ DMA সাধারণত সরাসরি SRAM-এ যায়, cache-এর পাশ কাটিয়ে।
PC-তে বড় processor-গুলো সাধারণত hardware-এই coherent DMA দেয়: যন্ত্র মেমরিতে লিখলে processor-এর cache-এর পুরোনো কপি বাতিল হয় বা আপডেট হয় (bus snooping-এর মতো ব্যবস্থায়), যাতে driver লেখকের ঘাড়ে এই দায় কম থাকে। তবে এটি সব প্ল্যাটফর্মে সত্য নয়; অনেক ARM-এর SoC-তে Linux driver-কে DMA API দিয়ে এই কাজ করতে হয়। Microcontroller-এ শক্তি আর silicon-এর দাম কম রাখতে এই coherence-এর hardware সাধারণত রাখা হয় না, দায়টি firmware-এর।
সঠিক নকশার তিনটি পথ। এক, প্রতিবার হাতে: DMA পাঠানোর আগে buffer-এর অংশ cache clean (dirty মান মেমরিতে লেখা), DMA পাওয়ার পরে CPU পড়ার আগে cache invalidate (পুরোনো কপি বাতিল)। Cortex-M7-এর cache line ৩২ byte, তাই buffer-এর শুরু আর আকার ৩২-এর গুণিতক রাখতে হয়; নইলে একটি invalidate পাশের কোনো ভ্যারিয়েবলের সদ্য লেখা মানও মুছে দিতে পারে, যা খুবই কঠিন bug. দুই, MPU দিয়ে একটি SRAM অঞ্চলকে non-cacheable ঘোষণা করে সব DMA buffer সেখানে রাখা: সহজ আর নিরাপদ, কিন্তু সেই অঞ্চলে CPU-র কাজ ধীর। তিন, কিছু chip-এ এমন tightly-coupled memory (DTCM) থাকে যা cache-এর বাইরে; সেটি DMA পৌঁছাতে পারে কি না, তা chip-এর bus-এর ছবি দেখে ঠিক করতে হয়। কোনো একটিই সবার জন্য সেরা নয়; ছোট আর ঘন ঘন buffer-এর জন্য non-cacheable অঞ্চল, বড় আর কম ঘন ঘন buffer-এর জন্য clean/invalidate প্রচলিত।
মূল উপলব্ধি: Cache গতি দেয় কিন্তু একই data-র দুটি কপি তৈরি করে; যেখানে hardware coherence নেই, সেখানে DMA buffer-এর জন্য clean, invalidate, cache line-এ সাজানো বা non-cacheable অঞ্চল firmware-এর অপরিহার্য দায়িত্ব।
প্র ০৫DMA যেকোনো ঠিকানায় পড়তে-লিখতে পারে, CPU-র নিয়ম না মেনে। Firmware-এর নির্ভরযোগ্যতা আর নিরাপত্তার দিক থেকে এর অর্থ কী, আর PC-র জগতের IOMMU থেকে microcontroller কী শিখতে পারে?
DMA controller কোনো প্রোগ্রাম চালায় না, তাই তার “ভুল” মানে আসলে firmware-এর ভুল সংখ্যা: ভুল CMAR, ভুল CNDTR, বা বাতিল হয়ে যাওয়া buffer-এর ঠিকানা। কিন্তু ফলটি CPU-র নিজের ভুলের চেয়ে অনেক খারাপভাবে লুকোয়। CPU একটি null pointer-এ লিখলে Cortex-M-এ প্রায়ই সঙ্গে সঙ্গে fault হয়, আর stacked PC দেখায় কোন নির্দেশ দোষী (পর্ব ৬১)। DMA একটি stack-এর জায়গায় বা অন্য module-এর ভ্যারিয়েবলে লিখলে কোনো fault হয় না, কারণ ঠিকানাটি বৈধ SRAM; ক্ষতি দেখা দেয় অনেক পরে, অন্য জায়গায়। অনেক MCU-তে Cortex-M-এর MPU শুধু core-এর access দেখে, তাই MPU দিয়ে stack পাহারা দিলেও DMA-র ভুল লেখা থামে না; নির্দিষ্ট chip-এর manual-এ এটি মিলিয়ে দেখতে হয়।
PC-র জগতে একই সমস্যার নিরাপত্তার দিকটি অনেক আলোচিত: একটি ক্ষতিকর বা আপস-করা যন্ত্র, যেমন একটি বাইরের port-এ লাগানো যন্ত্র, DMA দিয়ে OS-এর মেমরি পড়তে বা বদলাতে পারে। এর প্রধান প্রতিরক্ষা IOMMU: CPU-র MMU যেমন প্রতিটি process-এর জন্য ঠিকানার মানচিত্র রাখে, IOMMU তেমনি প্রতিটি যন্ত্রের জন্য রাখে, আর OS শুধু নির্দিষ্ট buffer-গুলো সেই যন্ত্রের জন্য খোলে। বিস্তারিত Cybersecurity কোর্সের IoT-নিরাপত্তার অংশ আর পর্ব ৭৬-এ।
Microcontroller-এ সাধারণত IOMMU নেই, কিন্তু তার শিক্ষাগুলো firmware-এর অভ্যাসে আনা যায়। এক, ন্যূনতম অনুমতি: DMA buffer-গুলো একটি নির্দিষ্ট section-এ রাখুন (linker script, পর্ব ৩১), যাতে map file দেখেই বোঝা যায় DMA কোথায় লিখতে পারে, আর CMAR লেখার আগে একটি assert সেই সীমা পরীক্ষা করে। দুই, জীবনকাল: buffer কখনো stack-এ নয়, আর channel বন্ধ না করে buffer অন্য কাজে নয়। তিন, ত্রুটির পথ: TEIE চালু রেখে TE এলে channel আবার সাজানো আর ঘটনাটি লগ করা। চার, নতুন chip বাছার সময় দেখা যে DMA-র জন্য কোনো memory protection বা secure/non-secure ভাগ (যেমন Armv8-M-এর TrustZone-যুক্ত chip-এ) আছে কি না। এগুলোর কোনোটিই কঠিন নয়, কিন্তু মাঠে একটি অদৃশ্য memory corruption খোঁজার চেয়ে অনেক সস্তা।
মূল উপলব্ধি: DMA CPU-র সুরক্ষার দেয়াল মানে না, তাই তার ভুল নিঃশব্দ; IOMMU-র মূল ধারণা, অর্থাৎ যন্ত্র শুধু অনুমোদিত buffer ছোঁবে, microcontroller-এ static buffer, নির্দিষ্ট section, assert আর TE-এর পথ দিয়ে firmware নিজেই প্রয়োগ করে।
অনুশীলন
প্রথমে নিজে লিখুন বা হিসাব করুন, তারপর উত্তর খুলুন। প্রতিটি সংখ্যা এই পর্বের DMA মডেলে বা Python-এ চালিয়ে যাচাই করা।
-
নকশা ও বাস্তবায়ন — UART-এর আদেশ DMA দিয়ে: Cold-storage monitor-এর STM32F103-এ USART1 দিয়ে আদেশ আসে (যেমন
LIMIT 8.50). প্রতিটি byte-এর জন্য interrupt না নিয়ে DMA দিয়ে একটি ৬৪ byte-এর circular buffer-এ জমাতে চান। কোন DMA1 channel, CPAR-এ কী, CCR-এর মান কত (priority medium, HT আর TC চালু), আর main loop কীভাবে জানবে নতুন কয়টি byte এসেছে? সাজানোর C function লিখুন।USART1_RX → DMA1 channel ৫ (RM0008 সারণি ৭৮)। CPAR = USART1-এর DR = 0x40013804 (USART1-এর base 0x40013800 + DR-এর offset 0x04). CMAR = static buffer. CNDTR = 64. CCR: PL = 01 (0x1000), MINC (0x80), CIRC (0x20), HTIE (0x4), TCIE (0x2), EN (0x1); PSIZE = MSIZE = 00 (৮ বিট), DIR = 0 (peripheral থেকে পড়া)। মোট 0x10A7 (HT/TC ছাড়া 0x10A1); মান দুটি মডেলের
PL(1) | MINC | CIRC | HTIE | TCIE | ENচালিয়ে মেলানো।static volatile uint8_t rx_buf[64]; /* static, কখনো stack-এ নয় */ static uint32_t rx_tail; /* main যেখানে পর্যন্ত পড়েছে */ void uart_rx_dma_init(void) { RCC->AHBENR |= RCC_AHBENR_DMA1EN; /* DMA1-এর clock */ DMA1_Channel5->CCR = 0; /* বন্ধ করে সাজানো */ DMA1_Channel5->CPAR = (uint32_t)&USART1->DR; DMA1_Channel5->CMAR = (uint32_t)rx_buf; DMA1_Channel5->CNDTR = 64; DMA1_Channel5->CCR = 0x10A6; /* EN ছাড়া বাকি বিট */ DMA1_Channel5->CCR |= 1u; /* EN */ USART1->CR3 |= USART_CR3_DMAR; /* শেষে peripheral-এর DMA */ } uint32_t uart_rx_available(void) { uint32_t head = 64u - DMA1_Channel5->CNDTR; /* DMA-র পরের ঘর */ return (head - rx_tail) % 64u; }মূল কৌশল: DMA-র লেখার অবস্থান (ring buffer-এর head) = 64 − CNDTR, কারণ CNDTR বলে কয়টি বাকি। Main loop নিজের tail রাখে, আর পার্থক্য (৬৪-এর ভাগশেষে) নতুন byte-এর সংখ্যা; ৬৪টির বেশি জমে গেলে (main ৬৪ byte-এর বেশি পিছিয়ে) এই হিসাব overrun ধরতে পারে না, তাই HT/TC-এর handler-এ একটি পাক-গোনা রাখুন। নামগুলো (
DMA1_Channel5,RCC_AHBENR_DMA1EN,USART_CR3_DMAR) CMSIS-ধাঁচের device header-এর; কোর্সের board-এ DMA নেই, তাই এটি board-এ চালানো নয়, হিসাব আর মডেলে যাচাই। UART-এর frame আর ring buffer-এর বিস্তারিত পর্ব ৪৯ (UART)-এ। -
ভুল খুঁজুন — চার মিনিট পরে crash: একজন লিখলেন:
void start_adc(void) { uint16_t buf[16]; DMA1_Channel1->CCR = 0x25A7; DMA1_Channel1->CPAR = (uint32_t)&ADC1->DR; DMA1_Channel1->CMAR = (uint32_t)buf; DMA1_Channel1->CNDTR = 16; ADC1->CR2 |= ADC_CR2_DMA; }. HT/TC-এর handler-এ তিনিDMA1->IFCR = 0xFFFFFFFF;লেখেন। কখনো ঠিক চলে, কখনো কিছুক্ষণ পরে HardFault. অন্তত তিনটি ভুল বের করুন।এক, buffer stack-এ:
buffunction-এর local;start_adcফিরে এলে সেই জায়গা অন্য function-এর frame-এ যায়, অথচ circular DMA সেখানে চিরকাল লিখতে থাকে: ফেরার ঠিকানা বা অন্য ভ্যারিয়েবল নষ্ট, তাই কখনো কখনো HardFault. ঠিক রূপ:static volatile uint16_t buf[16];function-এর বাইরে। দুই, ক্রম উল্টো: CCR-এ 0x25A7 লেখার সঙ্গে EN = 1, তারপর CPAR, CMAR আর CNDTR লেখা যায় না (RM0008: শুধু channel বন্ধ থাকলে), তাই channel পুরোনো বা শূন্য মান নিয়ে চলে; আর CNDTR = 0 হলে কোনো transfer-ই হয় না। ঠিক ক্রম: CCR = 0, তারপর তিনটি register, তারপর EN-সহ CCR, সবশেষে ADC-র DMA বিট। আর DMA-র clock (AHBENR-এর DMA1EN) চালু করা নেই। তিন, সব ফ্ল্যাগ মোছা:IFCR = 0xFFFFFFFFসাতটি channel-এরই ফ্ল্যাগ মুছে দেয়, তাই অন্য channel-এর (যেমন UART-এর) TC হারিয়ে যেতে পারে। শুধু channel ১:DMA1->IFCR = 1u;(CGIF1) বা নির্দিষ্ট বিট। মডেলেIFCR(0b0001)শুধু channel ১-এর চারটি বিট মোছে, তা অংশ ৪-এর run-এ দেখা গেছে। -
আগে বলুন, তারপর মেলান — CNDTR আর ফ্ল্যাগ: একটি circular channel-এ CNDTR = 10, HTIE আর TCIE চালু, ১৬ বিটের data, MINC. Peripheral পরপর ২৩টি request তোলে। কোন কোন transfer-এর পরে HT আর TC interrupt আসবে, ২৩টির পরে CNDTR কত, আর পরের নমুনা buffer-এর কোন ঘরে যাবে?
HT আসে যখন CNDTR = 10 ÷ 2 = 5, অর্থাৎ ৫টি transfer-এর পরে; TC আসে ১০টির পরে, তখন circular reload-এ CNDTR আবার 10. তাই HT: ৫ আর ১৫ নম্বর transfer-এ; TC: ১০ আর ২০ নম্বরে। ২০-এর পরে CNDTR = 10, আরও তিনটি transfer-এ 7. পরের ঘর = 10 − 7 = ৩ (ঘর ০ থেকে গুনে), অর্থাৎ CMAR + 3 × 2 byte. মডেলে চালিয়ে ফল:
[(5, 'HT'), (10, 'TC'), (15, 'HT'), (20, 'TC')] CNDTR 7 next idx 3. -
হিসাব — CPU-র ভার আর buffer-এর আকার: (ক) কোর্সের board-এর মাপা 20 cycle-এর ISR দিয়ে 8 MHz-এ 48 kHz-এ নমুনা নিলে CPU-র কত শতাংশ যাবে? (খ) DMA আর ping-pong দিয়ে 10 kHz-এ নমুনা নিতে চান, আর প্রতিটি অর্ধেক প্রক্রিয়ায় CPU-র 3 ms লাগে। Buffer-এর ন্যূনতম মোট আকার কত, আর সুবিধার জন্য ২-এর ঘাত নিলে কোনটি, তখন অর্ধেক ভরতে কত সময়?
(ক) 20 × 48 000 ÷ 8 000 000 = 0.12, অর্থাৎ 12%; আসল chip-এ exception-এ ঢোকা-বেরোনো আর ADC-র অপেক্ষা যোগ হলে আরও বেশি। (খ) শর্ত P ≤ (N ÷ 2) × Ts; Ts = 0.1 ms, তাই N ÷ 2 ≥ 3 ÷ 0.1 = 30, N ≥ 60. ২-এর ঘাত নিলে N = 64; তখন অর্ধেক (৩২টি নমুনা) ভরতে 3.2 ms, যা 3 ms-এর চেয়ে মাত্র 0.2 ms বেশি: margin খুব কম, interrupt-এর latency আর অন্য ISR-এর জন্য N = 128 (অর্ধেক 6.4 ms) নেওয়াই নিরাপদ। হিসাবগুলো Python-এ চালিয়ে মেলানো:
48k load 12.0 %,half 30 N 60,N=64 half time ms 3.2.
নিজেকে যাচাই করুন
ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।
ক্রমSTM32F103-এ ADC1-এর নমুনা DMA1 channel ১ দিয়ে circular buffer-এ নেওয়ার ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)
- RCC-র AHBENR-এ DMA1EN দিয়ে DMA1-এর clock চালু করা
- Channel বন্ধ অবস্থায় CPAR-এ ADC1-এর DR, CMAR-এ static buffer আর CNDTR-এ ঘরের সংখ্যা লেখা
- CCR-এ দিক, মাপ, MINC, CIRC, priority আর HTIE/TCIE বসানো
- CCR-এর EN বিট 1 করে channel চালু করা
- ADC_CR2-এর DMA বিট 1 করে রূপান্তর শুরু করা
STM32F103-এর DMA1-এ দুটি channel একই সময়ে request তুলেছে: channel ২ আর channel ৫, দুটিরই CCR-এ PL = 10 (high). কোনটি আগে সেবা পাবে?
- যে আগে request তুলেছে
- Channel ৫, কারণ বড় নম্বর
- Channel ২, কারণ ছোট নম্বর
- পালাক্রমে, round-robin
একটি DMA channel circular mode-এ, CNDTR-এর শুরুর মান 16, HTIE আর TCIE চালু। পরপর ২০টি transfer-এর পরে CNDTR কত, আর এর মধ্যে মোট কয়টি interrupt এসেছে?
- CNDTR = 0, interrupt ১টি
- CNDTR = 12, interrupt ২টি
- CNDTR = 12, interrupt ৩টি
- CNDTR = 4, interrupt ২টি
একটি ADC প্রতি 0.5 ms-এ একটি নমুনা দেয়, DMA ping-pong-এ ১২৮ ঘরের buffer ভরে, আর CPU প্রতিটি অর্ধেক প্রক্রিয়া করতে P সময় নেয়। নমুনা না হারানোর জন্য P-এর সর্বোচ্চ সীমা কত?
- 0.5 ms
- 64 ms
- 16 ms
- 32 ms
একটি function-এর ভেতরে uint8_t buf[32]; ঘোষণা করে তার ঠিকানা একটি circular DMA channel-এর CMAR-এ দেওয়া হলো, তারপর function ফিরে এল। সবচেয়ে সম্ভাব্য ফল কী?
- DMA পরে অন্য function-এর stack-এর data নষ্ট করবে, এলোমেলো crash হতে পারে
- Compiler error দেবে
- Function ফেরার সঙ্গে DMA নিজে থেকেই থেমে যাবে
- DMA সঙ্গে সঙ্গে transfer error দেবে
একটি Cortex-M7 microcontroller-এ data cache চালু। DMA একটি UART-এর RX buffer-এ নতুন data লিখেছে, TC এসেছে। CPU buffer পড়ার আগে কী করতে হবে, যাতে পুরোনো মান না পড়ে?
- Buffer-এর অংশ cache clean করা
- শুধু buffer-কে volatile ঘোষণা করা
- Buffer-এর অংশ cache invalidate করা
- CNDTR আবার লেখা
STM32F1-এর DMA_CCR-এর মান 0x25A7. নিচের কোন বর্ণনা ঠিক?
- Memory-to-memory, ৩২ বিট, circular
- Peripheral থেকে memory, ১৬ বিট, MINC, circular, HT ও TC চালু, priority high
- Memory থেকে peripheral, PINC চালু, priority low
- Channel বন্ধ, ৮ বিট, শুধু TC চালু
শব্দকোষ
লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:
মনে রাখুন
- কেন DMA: CPU দিয়ে নমুনা নিলে খরচ হারের সমানুপাতিক, আর critical section-এ tick হারায় (board-এ ২৭ tick-এ ২৪ নমুনা); DMA peripheral-কে সময়মতো সেবা দেয়, CPU-কে মুক্ত রাখে।
- STM32F1-এর channel: CPAR, CMAR, CNDTR, CCR; ISR/IFCR-এ প্রতি channel ৪ বিট; EN = 0 অবস্থায় সাজানো, EN সবশেষে, peripheral-এর DMA বিট তারও পরে; ADC1 → channel ১.
- Circular + HT/TC: গোনা শেষে নিজে থেকে reload; অর্ধেকে HT, পুরোতে TC; এভাবেই double buffering, শর্ত P ≤ (N ÷ 2) × Ts, আর overrun নিঃশব্দ।
- Priority আর error: আগে PL, সমান হলে ছোট channel নম্বর; memory-to-memory circular নয়; bus error-এ TEIF আর hardware EN মোছে।
- Firmware-এর নিয়ম: buffer static আর জোড় মাপের, CPU-র দিকে volatile বা barrier, IFCR-এ শুধু নিজের বিট, cache-যুক্ত chip-এ clean/invalidate; DMA দ্রুত নয়, মুক্ত, তাই ছোট কাজে সরল কোড।
আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ
- মাইক্রোপ্রসেসর, এমবেডেড সিস্টেম ও IoT · কোর্স হোম৮৫টি পর্বপুরো কোর্সের মানচিত্র আর বাজারঘরের দুটি device-এর পথ।
- পর্ব ২৭ · 8251 USART আর 8237 DMA controllerআগের ভিত্তিHOLD/HLDA, terminal count, autoinitialize আর block transfer-এর ক্লাসিক রূপ।
- পর্ব ৩৯ · এমবেডেড memoryআগের ভিত্তিStatic allocation আর ring buffer, যেখানে DMA-র buffer বসে।
- Computer Architecture পর্ব ৫২ · Interrupt আর DMAপাশের ট্র্যাকPolling, interrupt আর DMA-র সাধারণ তত্ত্ব আর তুলনা।
- DSA পর্ব ১৪ · Queue আর dequeপাশের ট্র্যাকCircular queue-এর data structure, যার hardware রূপ circular DMA.