সরাসরি পর্বে যান
পর্ব ৩৬ · ৮৫-এর মধ্যে · মডিউল ৬

C-তে memory-mapped register — pointer, struct আর CMSIS

Memory-Mapped Registers in C — Fixed-Address Pointers, Volatile Register Structs, offsetof/static_assert Checks and CMSIS Conventions on ARM Cortex-M

Taught in Bangla, this lesson turns datasheet addresses into C: a volatile pointer cast, then a register-block struct mapped at the peripheral base. Clang output shows a struct produces the same code as hand-written addresses,. On the course's virtual BG-M3 board it reads ADC1->DR (0x564 = 1380 counts for 1400 g), shows a forgotten reserved word causing a bus error and HardFault, and catches it at build time with offsetof and _Static_assert. CMSIS conventions close it.

এই পর্বে যা শিখবেন

  • একটি স্থির ঠিকানাকে volatile pointer-এ cast করে register পড়া-লেখা, আর macro-র বন্ধনী কেন জরুরি
  • একটি peripheral-এর register block-কে C struct দিয়ে ঢাকা: base address + offset, ফাঁকা ঘর (RESERVED) আর __I/__O/__IO
  • offsetof, sizeof আর _Static_assert দিয়ে struct-এর layout datasheet-এর সঙ্গে মেলানো, padding চেনা
  • Clang যে Thumb code বানায় তা পড়া: movw/movt দিয়ে base, আর ldr r0, [r0, #8]-এ offset
  • CMSIS-এর core header-এর ধারণা (NVIC, SysTick, SCB), device header আর SVD ফাইলের ভূমিকা

১ · Register মানে একটি ঠিকানা — pointer cast দিয়ে প্রথম ছোঁয়া

Microcontroller-এর UART, ADC বা GPIO-কে নিয়ন্ত্রণ করা হয় কয়েকটি register দিয়ে। Cortex-M-এ এই register-গুলো আলাদা কোনো port-এ নয়, সাধারণ মেমরির ঠিকানায় বসানো: একে বলে memory-mapped I/O. 8085-এর IN/OUT আর memory-mapped I/O-র পার্থক্য আপনি পর্ব ২৩-এ (I/O interfacing) দেখেছেন, আর বাজারঘর board-এর পুরো ঠিকানা-মানচিত্র পর্ব ৩১-এ (Memory map আর linker script). এই পর্বের প্রশ্ন একটাই: C ভাষায় ঠিক কীভাবে সেই ঠিকানায় পৌঁছাবেন, যাতে code পড়তে সহজ হয়, compiler ভুল optimization না করে, আর ভুল ঠিকানা build-এর সময়েই ধরা পড়ে।

উপমা — মার্কেটের একটি গলি: শহরের কোনো পুরোনো মার্কেটের একটি গলির কথা ভাবুন। গলির মুখের ঠিকানা সবাই জানে, আর ভেতরের দোকানগুলো পরপর: ১ নম্বর, ২ নম্বর, ৩ নম্বর। কোনো দোকান খুঁজতে পুরো শহরের ঠিকানা মুখস্থ লাগে না; “গলির মুখ থেকে তিন নম্বর দোকান” বললেই চলে। একটি peripheral ঠিক এমন: তার register-গুলো একটি ঠিকানা থেকে শুরু করে পরপর বসানো। গলির মুখ হলো base address, দোকানের নম্বর হলো offset. মাঝে মাঝে একটি দোকান খালি পড়ে থাকে, কিন্তু নম্বর তবুও গোনা হয়। এই খালি দোকানটির কথা ভুলে গেলে কী হয়, তা এই পর্বের সবচেয়ে বড় শিক্ষা।

লেখার নিয়ম: এই মডিউলে hex লেখা হয় C-র ধাঁচে, 0x দিয়ে: 0x40012400. সব ঠিকানা, offset, register-এর মান আর Clang-এর output এসেছে নিজের lab-এ আসল build থেকে: Clang 22.1.8 (PyPI-র ziglang 0.17.1, MIT; LLVM অংশ Apache-2.0 with LLVM exception), --target=thumbv7m-none-eabi -mcpu=cortex-m3, আর চালানো হয়েছে কোর্সের virtual বাজারঘর board BG-M3-এ (Unicorn 2.1.4: binding BSD, engine GPLv2). BG-M3 কোনো আসল পণ্য নয়; আসল Cortex-M3 chip-এর আদলে বানানো শেখার মডেল, যার peripheral-এর register STM32-এর অভ্যাসে নামকরণ করা কিন্তু সরল (পর্ব ০৬; reference lab-এর README, Spec decision 17).

সবচেয়ে সরাসরি পথ হলো একটি সংখ্যাকে pointer-এ cast করা। Pointer নিজে কী, * আর & কীভাবে কাজ করে, তা C কোর্সের পর্ব ১৭-এ (Pointer-এর ভিত্তি) আছে; এখানে শুধু embedded দিকটি। বাজারঘর board-এর ADC-র ফলাফল register (DR) বসে 0x40012408 ঠিকানায় (README-র memory map: ADC1 0x40012400, DR offset 0x08). তাহলে:

/* 1: raw address cast, one macro per register */
#define ADC1_SR (*(volatile uint32_t *)0x40012400u)
#define ADC1_CR (*(volatile uint32_t *)0x40012404u)
#define ADC1_DR (*(volatile uint32_t *)0x40012408u)

uint32_t adc_read_raw(void)
{
    ADC1_CR = 3u;                         /* ADON | SWSTART */
    while ((ADC1_SR & 2u) == 0) { }       /* wait for EOC (bit 1) */
    return ADC1_DR;
}

একটি macro-কে ভেতর থেকে বাইরে পড়ুন। 0x40012408u একটি unsigned সংখ্যা মাত্র। (volatile uint32_t *) তাকে বলে: “এটি একটি ঠিকানা, যেখানে একটি ৩২-bit unsigned মান থাকে, আর সেই মান program-এর অজান্তে বদলাতে পারে।” সামনের * সেই ঠিকানার মানটি বের করে। ফলে ADC1_DR দেখতে variable-এর মতো, কিন্তু প্রতিবার পড়লে CPU সত্যিই bus-এ ঠিকানা পাঠায় আর hardware উত্তর দেয়।

volatile এখানে বাধ্যতামূলক। এটি না থাকলে compiler ভাবতে পারে, “এই loop-এর ভেতরে কেউ ADC1_SR বদলায় না, তাই একবার পড়লেই যথেষ্ট।” volatile কী করে আর কী করে না (atomic করে না, memory barrier নয়), সেই পুরো গল্প পর্ব ৩৪-এ (Embedded C — volatile, const, fixed-width integer). এই পর্বের ৪ নম্বর অংশে শুধু দেখবেন, register struct থেকে volatile বাদ পড়লে Clang ঠিক কী code বানায়।

সংখ্যার শেষের u-ও অকারণ নয়। 0x40012408 একটি int-এ ধরে না বলে C নিজেই তাকে বড় কোনো টাইপ দিত, কিন্তু u লিখে স্পষ্ট করা হলো এটি unsigned, আর ঠিকানার হিসাব (যেমন base + offset) কখনো ঋণাত্মক সংখ্যার অদ্ভুত নিয়মে পড়বে না। ঠিকানাকে সংখ্যা হিসেবে রাখতে হলে C-র মানক টাইপ uintptr_t (stdint.h), যা একটি pointer ধরার মতো বড়; Cortex-M-এ তা ৩২-bit.

এই পদ্ধতি কাজ করে, কিন্তু একটি peripheral-এ দশটি register থাকলে দশটি macro, আর chip-এ বিশটি peripheral থাকলে কয়েকশো। তার চেয়ে বড় সমস্যা: একই ধরনের দুটি UART থাকলে প্রতিটির জন্য আলাদা macro সেট লিখতে হয়, আর একটি driver function দুটিতেই চালানো যায় না। এর সমাধান struct.

২ · Register block থেকে C struct — base address আর offset

একটি struct-এর member-গুলোও মেমরিতে পরপর বসে, আর প্রতিটির একটি স্থির offset থাকে। তাহলে register block-এর মতো করে একটি struct লিখে তার একটি pointer peripheral-এর base address-এ বসালে প্রতিটি member ঠিক তার register-এর ওপর পড়ে। একে বলে register struct দিয়ে “ঢাকা” বা overlay. Struct-এর সাধারণ নিয়ম, -> অপারেটর আর padding C কোর্সের পর্ব ২২-এ (struct আর union) আছে; এখানে আমরা সেই নিয়মকে hardware-এর সঙ্গে মেলাব।

বাজারঘর board-এর README চারটি peripheral-এর register দেয়। নিচের ছকে সেগুলো struct-এর ভাষায়:

PeripheralBaseMember (offset)মন্তব্য
GPIOA0x40010800DIR 0x00, ফাঁকা 0x04, IDR 0x08, ODR 0x0C, BSRR 0x10, BRR 0x14PA0 বোতাম, PA5 সবুজ LED, PA6 alarm
UART0x40004400SR 0x00, DR 0x04, BRR 0x08, CR1 0x0CSR: RXNE b5, TC b6, TXE b7; CR1: RE b2, TE b3, UE b13
ADC10x40012400SR 0x00, CR 0x04, DR 0x08SR: EOC b1; CR: ADON b0, SWSTART b1; load cell চ্যানেল 0
SCB (core)0xE000ED00CPUID 0x00, ICSR 0x04, VTOR 0x08, AIRCR 0x0C …আসল ARM ঠিকানা, সব Cortex-M3-এ একই

GPIOA-র 0x04 ঘরটি খালি কেন? Board-এর নকশাকার STM32F1 পরিবারের অভ্যাস নিয়েছেন। সেখানে GPIO port-এর প্রথম দুটি word (CRL আর CRH) প্রতিটি pin-এর mode ঠিক করে, আর IDR 0x08-এ, ODR 0x0C-তে (ST-এর reference manual RM0008, GPIO register map). BG-M3 সেই দুই word-এর জায়গায় একটি সরল DIR রেখেছে, দ্বিতীয় word-টি ফাঁকা। IDR আর ODR-এর offset আসল chip-এর মতোই থেকে গেছে। এমন ফাঁকা ঘর আসল datasheet-এ খুব সাধারণ।

এবার নিজের লেখা একটি ছোট header. এটি reference lab-এর bazarghar.h-এর ধাঁচে, কিন্তু প্রতিটি offset-এর পাশে compile-এর সময়ের পরীক্ষা যোগ করা:

#include <stdint.h>
#include <stddef.h>                    /* offsetof */

#define __I  volatile const            /* read only  */
#define __O  volatile                  /* write only */
#define __IO volatile                  /* read/write */

typedef struct {
    __IO uint32_t DIR;                 /* 0x00 */
    uint32_t RESERVED0;                /* 0x04 hole in the map */
    __I  uint32_t IDR;                 /* 0x08 */
    __IO uint32_t ODR;                 /* 0x0C */
    __O  uint32_t BSRR;                /* 0x10 */
    __O  uint32_t BRR;                 /* 0x14 */
} GPIO_TypeDef;

typedef struct {
    __IO uint32_t SR;                  /* 0x00 EOC b1 */
    __IO uint32_t CR;                  /* 0x04 ADON b0, SWSTART b1 */
    __I  uint32_t DR;                  /* 0x08 12-bit result */
} ADC_TypeDef;

_Static_assert(offsetof(GPIO_TypeDef, ODR) == 0x0C, "GPIO ODR offset");
_Static_assert(sizeof(GPIO_TypeDef)        == 0x18, "GPIO block size");
_Static_assert(offsetof(ADC_TypeDef, DR)   == 0x08, "ADC DR offset");

#define GPIOA ((GPIO_TypeDef *)0x40010800u)
#define ADC1  ((ADC_TypeDef  *)0x40012400u)

তিনটি জিনিস লক্ষ করুন। এক, প্রতিটি member-এ type qualifier: __I মানে volatile const, তাই শুধু পড়া যায়; __O আর __IO দুটিই volatile, পার্থক্য শুধু মানুষের জন্য লেখা অর্থে। দুই, ফাঁকা ঘরের জন্য একটি নামওয়ালা member RESERVED0, যাকে কেউ ছোঁবে না, কিন্তু সে জায়গা ধরে রাখে। তিন, শেষে base address-কে struct pointer-এ cast করা macro, পুরোটা বাইরের বন্ধনীতে মোড়া। পুরো ফাইলে UART আর SCB-এর struct-ও আছে, আর মোট সাতটি _Static_assert.

Pointer macro ছাড়া আরেকটি পথও প্রচলিত আছে: register struct-এর একটি সাধারণ global variable ঘোষণা করে linker script দিয়ে তাকে ঠিক peripheral-এর ঠিকানায় বসানো (পর্ব ৩১-এর নিজের section-এ variable বসানোর কৌশল)। কিছু নির্মাতার header আর কিছু compiler-এর বিশেষ বাক্য (যেমন একটি variable-কে “এই ঠিকানায়” বলে দেওয়ার extension) এভাবে কাজ করে। ফল একই, শুধু ঠিকানা লেখা থাকে linker script-এ, C-তে নয়। এই কোর্সে আমরা CMSIS-এর pointer-macro পথই নেব, কারণ সেটি বহনযোগ্য আর সবচেয়ে প্রচলিত।

ছবি ৩৬.১ — GPIOA-র register block-এর ওপর দুটি struct

মাঝে hardware-এর আসল register; বাঁয়ে ঠিক struct (ফাঁকা ঘরসহ), ডানে ভুল struct (ফাঁকা ঘর বাদ)

GPIOA register block আর দুটি struct overlay ঠিক struct hardware ভুল struct base 0x40010800 +0x00 DIR দিক +0x04 ফাঁকা ঘর +0x08 IDR শুধু পড়া +0x0C ODR output +0x10 BSRR set/reset +0x14 BRR reset DIR RESERVED0 IDR ODR BSRR BRR DIR ✓ IDR ✗ (0x04) ODR ✗ (0x08) BSRR ✗ (0x0C) ODR-এ লেখা → read-only IDR-এ bus error, HardFault register-এর ঠিকানা = base + offsetof(member) ODR: 0x40010800 + 0x0C = 0x4001080C

এখন ADC1->DR লিখলে compiler কী হিসাব করে, এক এক ধাপে দেখুন। শেষ দুটি ধাপের instruction এই পর্বের আসল Clang build থেকে (৪ নম্বর অংশে পুরো listing):

1#define ADC1 ((ADC_TypeDef *)0x40012400u)2typedef struct { SR; CR; DR; } ADC_TypeDef;3uint32_t raw = ADC1->DR;4movw r0, #9216 ; movt r0, #163855ldr  r0, [r0, #8]6(board) 0x40012408 থেকে উত্তর
হিসাব
Base
Offset
ঠিকানা
মান
  1. Pointer তৈরি. ADC1 macro একটি সংখ্যা 0x40012400-কে ADC_TypeDef * বানায়। এখনো কোনো bus-access হয়নি; pointer মানে শুধু ঠিকানাটি মনে রাখা।
  2. Struct-এর layout. তিনটি member-ই uint32_t, প্রতিটি ৪ byte, padding ছাড়া পরপর: SR 0x00, CR 0x04, DR 0x08. এই offset-গুলোই README-র ADC1 register map.
  3. ঠিকানার হিসাব. ADC1->DR-এর ঠিকানা = base + offsetof(ADC_TypeDef, DR) = 0x40012400 + 0x08 = 0x40012408. এই যোগ compiler compile-এর সময়েই করে ফেলে।
  4. Base register-এ তোলা. একটি ৩২-bit ধ্রুবক একবারে তোলা যায় না, তাই Clang দুটি instruction দেয়: movw নিচের ১৬ bit (9216 = 0x2400), movt ওপরের ১৬ bit (16385 = 0x4001). ফলে r0 = 0x40012400.
  5. Offset instruction-এর ভেতরে. ldr r0, [r0, #8] মানে “r0 + 8 ঠিকানা থেকে একটি word পড়া”; offset আলাদা যোগ করতে হয় না, load instruction-এর ঠিকানা-গণনাতেই থাকে। একই base দিয়ে SR ([r0]) আর CR ([r0, #4])-ও ছোঁয়া যায়।
  6. Hardware-এর উত্তর. Board-এ 1400 g রাখা থাকলে ADC দেয় 400 + 0.7 × 1400 = 1380 = 0x564 count (README-র load-cell মডেল)। DR পড়ার সঙ্গে সঙ্গে board SR-এর EOC bit মুছে দেয় (Spec decision 25): একটি পড়ার পার্শ্বফল।

৩ · Volatile struct pointer দিয়ে আসল register পড়া

তত্ত্ব যথেষ্ট; এবার board-এ চালিয়ে দেখা। নিচের firmware নিজের header bg_regs.h দিয়ে UART, ADC, GPIO আর SCB-এর কয়েকটি register পড়ে, আর প্রতিটির ঠিকানা (&UART->BRR) ও মান UART-এ ছাপে। uart_init() আর ছাপার সাহায্য reference lab-এর bglib থেকে।

#include "bg_regs.h"
#include "bglib.h"
/* show(name, address, value) prints both in hex */

int main(void)
{
    uart_init();                         /* writes UART->BRR and UART->CR1 */
    show("UART->SR  ", &UART->SR, UART->SR);
    show("UART->BRR ", &UART->BRR, UART->BRR);
    show("UART->CR1 ", &UART->CR1, UART->CR1);

    ADC1->CR = 1u;                        /* ADON */
    ADC1->CR = 1u | 2u;                   /* ADON | SWSTART */
    uint32_t sr = ADC1->SR;
    while ((ADC1->SR & 2u) == 0) { }      /* EOC */
    uint32_t raw = ADC1->DR;              /* reading DR clears EOC */
    show("ADC1->SR  ", &ADC1->SR, sr);
    show("ADC1->DR  ", &ADC1->DR, raw);
    show("ADC1->SR  ", &ADC1->SR, ADC1->SR);
    /* grams = div_round((raw - 400) * 2000, 1400) */

    GPIOA->DIR = 1u << 5;                 /* PA5 LED output, PA0 input */
    GPIOA->BSRR = 1u << 5;                /* LED on */
    show("GPIOA->IDR", &GPIOA->IDR, GPIOA->IDR);
    show("SCB->CPUID", &SCB->CPUID, SCB->CPUID);
    show("SCB->VTOR ", &SCB->VTOR, SCB->VTOR);
    SIM_EXIT = 0;                         /* emulator only */
    for (;;) { }
}

Script-এ পাল্লায় 1400 g রাখা আর বোতাম চাপা (regs.json: {"t_ms": 0, "grams": 1400}, {"t_ms": 0, "button": 1}). Build আর run reference lab-এর নিয়মে, নিজের lab-এর ফোল্ডার থেকে (সত্যিকারের run; Clang 22.1.8 + LLD 22.1.8):

~/lab/mmr $ python -B mk.py fw build/regs.elf regs.c
built regs.elf
~/lab/_ref $ python -B board.py run ../mmr/build/regs.elf --script ../mmr/regs.json
[     0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[     0.0000 ms] > load on the scale: 1400 g
[     0.0000 ms] > button pressed
[     0.0473 ms] UART: UART->SR   @ 0x40004400 = 0x000000C0
[     0.0907 ms] UART: UART->BRR  @ 0x40004408 = 0x00000045
[     0.1343 ms] UART: UART->CR1  @ 0x4000440C = 0x0000200C
[     0.1799 ms] UART: ADC1->SR   @ 0x40012400 = 0x00000002
[     0.2233 ms] UART: ADC1->DR   @ 0x40012408 = 0x00000564
[     0.2666 ms] UART: ADC1->SR   @ 0x40012400 = 0x00000000
[     0.2903 ms] UART: grams = 1400
[     0.2913 ms] GPIO PA5 LED ON
[     0.3344 ms] UART: GPIOA->IDR @ 0x40010808 = 0x00000021
[     0.3781 ms] UART: SCB->CPUID @ 0xE000ED00 = 0x412FC231
[     0.4216 ms] UART: SCB->VTOR  @ 0xE000ED08 = 0x08000000
[     0.4225 ms] exit(0) after 3380 cycles

একটি সূক্ষ্ম কথা আগে। &UART->BRR লিখলে register পড়া হয় না: & শুধু ঠিকানাটি হিসাব করে (base + 0x08), bus-এ কিছু যায় না। তাই ঠিকানা ছাপা নিরাপদ, এমনকি read-to-clear register-এরও। পড়া ঘটে কেবল UART->BRR-এর মান ব্যবহার করলে। এই পার্থক্য পরে খুব কাজে লাগবে, যখন দেখবেন একটি অপ্রয়োজনীয় পড়াও hardware-এর অবস্থা বদলায়।

প্রতিটি ঠিকানা README-র map-এর সঙ্গে হুবহু মেলে, অর্থাৎ struct-এর layout ঠিক। এখন মানগুলো কেন এমন, এক এক করে:

7uart_init();  /* BRR, CR1 */9show(.. UART->BRR ..)8show(.. UART->SR ..)12ADC1->CR = 1u ∣ 2u;13sr = ADC1->SR;15raw = ADC1->DR;18show(.. ADC1->SR ..)23show(.. GPIOA->IDR ..)
Register (board run থেকে)
Register
ঠিকানা
মান
Bit
  1. UART চালু করা. uart_init() লেখে UART->CR1 = UE ∣ TE ∣ RE = 0x2000 + 0x8 + 0x4 = 0x200C. পড়ে দেখা গেল ঠিক সেই মানই আছে, অর্থাৎ লেখা আর পড়া একই ঠিকানায় (0x4000440C) গেছে।
  2. Baud-rate ভাজক. BRR-এ লেখা হয়েছে (8 000 000 + 57 600) ÷ 115 200, পূর্ণসংখ্যায় 69 = 0x45. Board এটি শুধু রেখে দেয়, সময় মাপে না (Spec decision 24); baud rate-এর পুরো হিসাব পর্ব ৪৯-এ (UART).
  3. Status register. UART->SR = 0xC0: bit 7 TXE আর bit 6 TC দুটিই 1 (পাঠানোর জায়গা খালি), bit 5 RXNE = 0 (কিছু আসেনি)। SR-কে __I রাখা হয়েছে, তাই ভুলে এতে লেখার চেষ্টা করলে compile-ই হবে না।
  4. ADC শুরু আর EOC. ADC1->CR-এ ADON আর SWSTART লেখার পরে board রূপান্তর সঙ্গে সঙ্গে শেষ করে (Spec decision 25), তাই প্রথম পড়াতেই SR = 0x2: bit 1 EOC = 1. আসল chip-এ এখানে কয়েক µs অপেক্ষা লাগত; সেজন্যই while loop.
  5. ফলাফল পড়া. ADC1->DR = 0x564 = 1380 count. বাজারঘরের calibration: (1380 − 400) × 2000 ÷ 1400 = 980 × 2000 ÷ 1400 = 1400 g, আউটপুটের grams = 1400.
  6. পড়ার পার্শ্বফল. একই SR আবার পড়লে এবার 0x0: DR পড়াটাই EOC মুছে দিয়েছে। Register সাধারণ variable নয়: একটি পড়াও hardware-এর অবস্থা বদলাতে পারে। এই কারণেই প্রতিটি পড়া সত্যিই ঘটা চাই, আর অপ্রয়োজনীয় পড়াও ক্ষতিকর।
  7. GPIO input. IDR = 0x21 = 0b100001: bit 5 = 1, কারণ PA5 output আর BSRR দিয়ে জ্বালানো হয়েছে (IDR output pin-এর অবস্থাও দেখায়, Spec decision 23); bit 0 = 1, কারণ PA0-এর বোতাম চাপা। ODR-এ read-modify-write-এর বদলে BSRR দিয়ে কেন set করা নিরাপদ, তা পর্ব ৩৫-এর (Register-এর bit manipulation) বিষয়।

শেষ দুটি লাইন core-এর অংশ। SCB->CPUID = 0x412FC231: ARMv7-M-এর নিয়মে ওপরের byte 0x41 মানে implementer ARM, আর part number 0xC23 মানে Cortex-M3; board এটিকে r2p1 হিসেবে ফেরত দেয়। SCB->VTOR = 0x08000000, কারণ VTOR বলে vector table flash-এর শুরুতে (পর্ব ৩২)। এই দুটি ঠিকানা সব Cortex-M3-এ একই, chip-নির্মাতা যেই হোন।

৪ · Clang কী বানায় — macro, struct আর volatile-হীন struct

অনেকে ভাবেন struct pointer “ধীর”, কারণ দেখতে বেশি জটিল। তর্ক না করে compiler-কেই জিজ্ঞেস করা যাক। একই ADC-পড়া তিনভাবে লেখা হলো: ১ নম্বর অংশের macro (adc_read_raw), struct pointer (adc_read_struct), আর একই struct কিন্তু member-এ volatile নেই (adc_read_plain):

/* 2: volatile struct pointer (CMSIS style) */
uint32_t adc_read_struct(void)
{
    ADC1->CR = 3u;
    while ((ADC1->SR & 2u) == 0) { }
    return ADC1->DR;
}

/* 3: the same struct, but WITHOUT volatile */
typedef struct { uint32_t SR, CR, DR; } ADC_Plain;
#define ADC1_PLAIN ((ADC_Plain *)0x40012400u)

uint32_t adc_read_plain(void)
{
    ADC1_PLAIN->CR = 3u;
    while ((ADC1_PLAIN->SR & 2u) == 0) { }
    return ADC1_PLAIN->DR;
}

সত্যিকারের run: clang --target=thumbv7m-none-eabi -mcpu=cortex-m3 -Os -S access.c (Clang 22.1.8). Directive-এর লাইন বাদ দিয়ে:

adc_read_raw:                    adc_read_struct:
    movw  r0, #9216                  movw  r0, #9216
    movt  r0, #16385                 movt  r0, #16385
    movs  r1, #3                     movs  r1, #3
    str   r1, [r0, #4]               str   r1, [r0, #4]
.LBB0_1:                         .LBB1_1:
    ldr   r1, [r0]                   ldr   r1, [r0]
    lsls  r1, r1, #30                lsls  r1, r1, #30
    bpl   .LBB0_1                    bpl   .LBB1_1
    ldr   r0, [r0, #8]               ldr   r0, [r0, #8]
    bx    lr                         bx    lr

adc_read_plain:
    movw  r0, #9216
    movt  r0, #16385
    movs  r1, #3
    str   r1, [r0, #4]
    ldrb  r1, [r0]
    lsls  r1, r1, #30
    itt   mi
    ldrmi r0, [r0, #8]
    bxmi  lr
.LBB2_1:
    b     .LBB2_1

প্রথম দুটি function অক্ষরে অক্ষরে এক: struct pointer-এর কোনো বাড়তি খরচ নেই। Base একবার r0-তে উঠেছে, তারপর CR [r0, #4], SR [r0], DR [r0, #8], ঠিক struct-এর offset. lsls r1, r1, #30 একটি চতুর কৌশল: bit 1-কে বাঁয়ে ৩০ ঘর সরিয়ে sign bit-এ আনে, তারপর bpl (“plus হলে লাফ”) মানে EOC এখনো 0 হলে আবার পড়তে যাওয়া। প্রতি পাকে ldr r1, [r0] সত্যিই SR পড়ছে।

তৃতীয়টিতে দুটি গুরুতর বদল। এক, SR একবারই পড়া হয়, তাও ldrb দিয়ে, অর্থাৎ ৩২-bit-এর বদলে ৮-bit load: compiler বুঝেছে শুধু bit 1 লাগবে, তাই ছোট load-ই যথেষ্ট। দুই, প্রথম পড়ায় EOC 0 হলে program চলে যায় .LBB2_1: b .LBB2_1-এ, একটি অসীম loop যেখানে আর কখনো SR পড়া হয় না। Compiler-এর যুক্তি নিখুঁত: সাধারণ মেমরিতে কেউ বদলায় না, তাই একবার 0 মানে চিরকাল 0. বাজারঘর board-এ রূপান্তর সঙ্গে সঙ্গে শেষ হয় বলে এই code হয়তো কাজ করে যেত; আসল chip-এ, যেখানে ADC কয়েক µs সময় নেয়, scale চিরকাল ঝুলে থাকত।

Access width-এর ফাঁদ: ldrb দেখায় যে volatile ছাড়া compiler register-এর পড়ার মাপও বদলাতে পারে। অনেক আসল peripheral শুধু ৩২-bit (word) access মানে; byte বা halfword access-এ ভুল মান দেয় বা bus error আনে, সেটি chip-এর reference manual-এ লেখা থাকে। volatile থাকলে বাস্তবে compiler-গুলো ঘোষিত মাপের access রাখে (C standard নিজে মাপের নিশ্চয়তা দেয় না, এটি compiler আর ABI-র প্রতিশ্রুতি)। তাই register struct-এর member-এর টাইপ datasheet-এর register-এর মাপের সঙ্গে মেলানো জরুরি। -O2-তে Clang loop-টিকে চারবার খুলে (unroll) লিখেছিল, কিন্তু প্রতিটি খোলা পাকেও ldr r1, [r0] ছিল; listing ছোট রাখতে এখানে -Os দেখানো।

volatile ঠিক কোথায় বসবে — তিনটি জায়গা, তিন অর্থ

C-র ঘোষণায় volatile-এর জায়গা বদলালে অর্থ বদলায়, আর এখানে AI থেকে মানুষ সবাই ভুল করে। volatile ADC_Plain *p মানে “p একটি সাধারণ pointer, যা একটি volatile struct-কে দেখায়”: struct-এর প্রতিটি member-এর access volatile. ADC_Plain * volatile p মানে “p নিজেই একটি volatile variable, কিন্তু সে যে struct দেখায় তা সাধারণ”। তৃতীয় পথ CMSIS-এর: struct-এর প্রতিটি member-এ __IO, তখন pointer সাধারণ হলেও সমস্যা নেই। প্রথম দুটি একই loop-এ পাশাপাশি compile করা হলো (সত্যিকারের run, where_vol.c, -Os):

wait_a:  /* volatile ADC_Plain *p */     wait_b:  /* ADC_Plain * volatile p */
    movw  r0, #9216                      sub   sp, #4
    movt  r0, #16385                     movw  r0, #9216
.LBB0_1:                                 movt  r0, #16385
    ldr   r1, [r0]                       str   r0, [sp]
    lsls  r1, r1, #30                .LBB1_1:
    bpl   .LBB0_1                        ldr   r0, [sp]
    ldr   r0, [r0, #8]                   ldrb  r0, [r0]
    bx    lr                             lsls  r0, r0, #30
                                         bpl   .LBB1_1
                                         ldr   r0, [sp]
                                         ldr   r0, [r0, #8]
                                         add   sp, #4
                                         bx    lr

wait_a হুবহু CMSIS-ধাঁচের struct-এর code: প্রতি পাকে SR-এর পুরো ৩২-bit পড়া। wait_b আরও মজার। Pointer-টি volatile বলে compiler তাকে stack-এ রেখে প্রতি পাকে ldr r0, [sp] দিয়ে আবার তোলে; pointer বদলে যেতে পারে ভেবে SR-ও প্রতি পাকে পড়তে হয়েছে, তাই এই ছোট উদাহরণে loop কাকতালীয়ভাবে কাজ করত। কিন্তু SR পড়া হচ্ছে ldrb দিয়ে, এক byte, কারণ struct-এর member-এর ওপর কোনো volatile-এর প্রতিশ্রুতি নেই। যে peripheral শুধু word access মানে, সেখানে এটি ভুল; আর একটু ভিন্ন code-এ compiler pointer একবার তুলে SR-এর পড়াও loop-এর বাইরে নিতে পারে। নিয়ম তাই সরল: volatile লাগে register-এর ওপর (member-এ বা pointer-এর লক্ষ্য-টাইপে), pointer variable-এর ওপর নয়।

৫ · Padding, alignment আর ফাঁকা ঘর — offset কে ঠিক করে

Struct-এর member কোথায় বসবে, তা ঠিক করে C-র alignment নিয়ম আর platform-এর ABI. Cortex-M-এর AAPCS-এ (ARM-এর procedure call standard) uint8_t-এর alignment 1, uint16_t-এর 2, uint32_t-এর 4. প্রতিটি member নিজের alignment-এর গুণিতক offset-এ বসে; দরকার হলে compiler মাঝে ফাঁকা byte বসায়, যাকে বলে padding. সব member uint32_t হলে padding কখনো আসে না, offset সোজা ০, ৪, ৮… তাই register struct-এ প্রায় সব member ৩২-bit রাখা হয়, আর ফাঁকা ঘর লেখা হয় নামওয়ালা RESERVED member দিয়ে, compiler-এর padding-এর ভরসায় নয়।

নিচের program C-র নিয়ম মেনে offset হিসাব করে, আর README বা ARM-এর দেওয়া offset-এর সঙ্গে মেলায়। চারটি struct: ঠিক GPIO, ফাঁকা ঘর ভুলে যাওয়া GPIO, মাপ মেশানো একটি “Mixed” struct, আর NVIC-এর মতো বড় array-ওয়ালা struct:

# C-র নিয়মে struct layout: প্রতিটি member নিজের মাপের গুণিতক ঠিকানায় বসে
def layout(members):
    off, big, rows = 0, 1, []
    for name, size, count in members:          # (নাম, এক ঘরের byte, কয়টি ঘর)
        off = (off + size - 1) // size * size  # দরকার হলে padding
        rows.append((name, off))
        off += size * count
        big = max(big, size)
    return rows, (off + big - 1) // big * big  # শেষে padding দিয়ে sizeof

SHEET = {"DIR": 0x00, "IDR": 0x08, "ODR": 0x0C, "BSRR": 0x10,   # README-র GPIO
         "ICER": 0x80, "ISPR": 0x100, "IP": 0x300}               # ARM-এর NVIC
W = 4  # uint32_t
TESTS = {
    "GPIO ঠিক": [("DIR", W, 1), ("RESERVED0", W, 1), ("IDR", W, 1),
                 ("ODR", W, 1), ("BSRR", W, 1), ("BRR", W, 1)],
    "GPIO ভুল": [("DIR", W, 1), ("IDR", W, 1), ("ODR", W, 1), ("BSRR", W, 1)],
    "Mixed":    [("CR", 1, 1), ("SR", W, 1), ("DR", 2, 1)],
    "NVIC":     [("ISER", W, 8), ("RES0", W, 24), ("ICER", W, 8), ("RES1", W, 24),
                 ("ISPR", W, 8), ("RES2", W, 24 + 8 + 24 + 8 + 56), ("IP", 1, 240)],
}
for title, members in TESTS.items():
    rows, size = layout(members)
    print(f"{title}: sizeof = {size} (0x{size:X})")
    for name, off in rows:
        if name.startswith("RES"):
            continue
        want = SHEET.get(name)
        note = "" if want is None else ("ঠিক" if want == off else f"ভুল, চাই 0x{want:02X}")
        print(f"   {name:5} 0x{off:03X}  {note}")

আসল আউটপুট (ব্রাউজারের Python):

GPIO ঠিক: sizeof = 24 (0x18)
   DIR   0x000  ঠিক
   IDR   0x008  ঠিক
   ODR   0x00C  ঠিক
   BSRR  0x010  ঠিক
   BRR   0x014
GPIO ভুল: sizeof = 16 (0x10)
   DIR   0x000  ঠিক
   IDR   0x004  ভুল, চাই 0x08
   ODR   0x008  ভুল, চাই 0x0C
   BSRR  0x00C  ভুল, চাই 0x10
Mixed: sizeof = 12 (0xC)
   CR    0x000
   SR    0x004
   DR    0x008
NVIC: sizeof = 1008 (0x3F0)
   ISER  0x000
   ICER  0x080  ঠিক
   ISPR  0x100  ঠিক
   IP    0x300  ঠিক

একটি ফাঁকা ঘর বাদ পড়তেই তার পরের প্রতিটি member ৪ byte করে সরে গেছে: ভুল একটি, কিন্তু ক্ষতি তিনটি register-এ। “Mixed”-এ CR এক byte, অথচ SR বসেছে 0x04-এ: মাঝে ৩ byte padding, শেষে আরও ২ byte, মোট 12. NVIC-এ মাঝের RESERVED array-গুলো (২৪টি করে word) ICER-কে 0x80-তে, ISPR-কে 0x100-তে আর byte-array IP-কে 0x300-তে ঠেলে দিয়েছে, যা ARM-এর NVIC map. এই ব্রাউজার-program শুধু নিয়মের মডেল; আসল সত্য compiler বলে, তাই পরের দুটি পরীক্ষা।

প্রথম পরীক্ষা board-এ: reference lab-এর bazarghar.h-এর NVIC আর SCB struct-এর offset, আর একই “Mixed” struct, Clang thumbv7m-এর জন্য হিসাব করে UART-এ ছাপল (সত্যিকারের run, offs.c):

~/lab/_ref $ python -B board.py run ../mmr/build/offs.elf
[     0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[     0.0462 ms] UART: offsetof(NVIC_Type, ICER) = 128 (0x080)
[     0.0902 ms] UART: offsetof(NVIC_Type, ISPR) = 256 (0x100)
[     0.1343 ms] UART: offsetof(NVIC_Type, IP)   = 768 (0x300)
[     0.1816 ms] UART: &NVIC->IP[1]  = 0xE000E000 + 1025 (0x401)
[     0.2235 ms] UART: offsetof(SCB_Type, SHP)   = 24 (0x018)
[     0.2709 ms] UART: &SCB->SHP[11] = 0xE000E000 + 3363 (0xD23)
[     0.3040 ms] UART: Mixed: CR SR DR at 0 (0x000)
[     0.3379 ms] UART:                     4 (0x004)
[     0.3715 ms] UART:                     8 (0x008)
[     0.4081 ms] UART: sizeof(Mixed)      = 12 (0x00C)
[     0.4089 ms] exit(0) after 3271 cycles

ব্রাউজারের মডেল আর আসল compiler একমত। দুটি ঠিকানা বিশেষ করে দেখার মতো। &NVIC->IP[1] = 0xE000E401: IRQ1-এর (বাজারঘর board-এ UART receive) priority byte. &SCB->SHP[11] = 0xE000ED23: SysTick-এর priority byte, reference header-এর NVIC_SetPriority(SysTick_IRQn, 3) যেখানে লেখে। NVIC-এর priority-র নিয়ম পর্ব ৩০-এ; এখানে শুধু দেখুন, এই ঠিকানা কেউ হাতে লেখেনি, struct-এর layout থেকে বেরিয়েছে।

প্রায় সব register ৩২-bit হলেও IP আর SHP কেন uint8_t-এর array? ARMv7-M-এ প্রতিটি interrupt-এর priority এক byte-এর একটি ঘর, চারটি করে একটি word-এ বসানো, আর স্থাপত্য এই register-গুলোতে byte access অনুমোদন করে। তাই NVIC->IP[1] = 0x10 লিখলে compiler একটি strb দেয়, যা পাশের তিনটি interrupt-এর priority ছোঁয় না। ৩২-bit member হলে একটি priority বদলাতে পুরো word পড়ে, বদলে, আবার লিখতে হতো, যার মাঝখানে interrupt এলে বিপদ হতে পারে। এখানে struct-এর টাইপ সরাসরি hardware-এর একটি নিশ্চয়তা প্রকাশ করে: কোন register byte ধরে ছোঁয়া নিরাপদ, তা datasheet বলে, আর struct সেই কথাটি compiler-কে জানায়।

দ্বিতীয় পরীক্ষা: একই নিয়ম আপনার নিজের চোখে, একটি সাধারণ computer-এ। নিচের C program কোনো register ছোঁয় না (host-এ 0x40010800 শুধু একটি সংখ্যা); শুধু offsetof, sizeof আর static_assert চালায়। Member সাজানোর ক্রম বদলালে মাপ কীভাবে বদলায়, সেটিও দেখায়:

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

typedef struct {
    volatile uint32_t DIR;        /* 0x00 */
    uint32_t RESERVED0;           /* 0x04 */
    volatile const uint32_t IDR;  /* 0x08 */
    volatile uint32_t ODR;        /* 0x0C */
    volatile uint32_t BSRR;       /* 0x10 */
    volatile uint32_t BRR;        /* 0x14 */
} GPIO_TypeDef;
_Static_assert(offsetof(GPIO_TypeDef, ODR) == 0x0C, "ODR must be at 0x0C");
_Static_assert(sizeof(GPIO_TypeDef) == 0x18, "GPIO block is 0x18 bytes");

typedef struct { uint8_t CR; uint32_t SR; uint16_t DR; } Mixed;
typedef struct { uint32_t SR; uint16_t DR; uint8_t CR; } Sorted;

#define SHOW(T, m) printf("%-7s %-4s offset %2zu\n", #T, #m, offsetof(T, m))

int main(void)
{
    uintptr_t base = 0x40010800u;          /* GPIOA on the board: only a number here */
    uintptr_t odr = base + offsetof(GPIO_TypeDef, ODR);
    printf("GPIOA->ODR = 0x%08lX + 0x%02zX = 0x%08lX\n",
           (unsigned long)base, offsetof(GPIO_TypeDef, ODR), (unsigned long)odr);
    SHOW(Mixed, CR); SHOW(Mixed, SR); SHOW(Mixed, DR);
    printf("sizeof(Mixed)  = %zu\n", sizeof(Mixed));
    SHOW(Sorted, SR); SHOW(Sorted, DR); SHOW(Sorted, CR);
    printf("sizeof(Sorted) = %zu\n", sizeof(Sorted));
    return 0;
}

আসল আউটপুট (Wandbox-এর GCC):

GPIOA->ODR = 0x40010800 + 0x0C = 0x4001080C
Mixed   CR   offset  0
Mixed   SR   offset  4
Mixed   DR   offset  8
sizeof(Mixed)  = 12
Sorted  SR   offset  0
Sorted  DR   offset  4
Sorted  CR   offset  6
sizeof(Sorted) = 8

দুটি _Static_assert নীরবে পার হয়েছে, তাই program compile হলো; ভুল হলে কোনো আউটপুটই আসত না। বড় থেকে ছোট ক্রমে সাজানো Sorted একই তিনটি তথ্য রাখে 8 byte-এ, Mixed-এর 12-র জায়গায়। সাধারণ ডেটার struct-এ এই কৌশল জায়গা বাঁচায়, কিন্তু register struct-এ ক্রম বদলানোর প্রশ্নই নেই: ক্রম ঠিক করে hardware, আপনি নন।

৬ · ভুল layout — board-এ HardFault, আর static_assert-এ build থামা

এবার জেনেবুঝে ভুল করা হলো। GPIO struct-এ RESERVED0 বাদ, কোনো পরীক্ষা নেই, আর firmware LED জ্বালাতে GPIOA->ODR-এ লেখে (bad_noassert.c):

typedef struct {
    volatile uint32_t DIR;        /* 0x00 */
    volatile const uint32_t IDR;  /* meant 0x08 - really 0x04! */
    volatile uint32_t ODR;        /* meant 0x0C - really 0x08! */
    volatile uint32_t BSRR;       /* meant 0x10 - really 0x0C! */
} GPIO_Bad;
#define GPIOA ((GPIO_Bad *)0x40010800u)

    uart_puts("LED on via ODR...\r\n");
    GPIOA->DIR = 1u << 5;
    GPIOA->ODR = 1u << 5;          /* lands on 0x40010808 = IDR */
    uart_puts("done\r\n");

Compiler কোনো সতর্কবার্তা দেয়নি: তার চোখে সব ঠিক। Board-এ (সত্যিকারের run):

~/lab/_ref $ python -B board.py run ../mmr/build/bad.elf --cycles 200000
[     0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[     0.0177 ms] UART: LED on via ODR...
[     0.0187 ms] bus error: write at unmapped peripheral address 0x40010808
[     0.0187 ms] HardFault: bus error at PC=0x0800007E main+0x1E
[    25.0000 ms] stopped: cycle limit (200000) reached after 200000 cycles

LED জ্বলেনি, “done” আসেনি। ODR-এ লেখা গেছে 0x40010808-এ, যা hardware-এর read-only IDR; board সেখানে লেখা গ্রহণ করে না, তাই bus error, আর Spec decision 19 অনুযায়ী সব fault যায় HardFault-এ। Startup-এর default handler একটি অসীম loop, তাই run থামল cycle-সীমায়। এখানে ভাগ্য ভালো, কারণ ভুল ঠিকানাটি লেখা নিষেধ বলে সঙ্গে সঙ্গে ধরা পড়ল। ভুল ঠিকানা যদি অন্য কোনো লেখার-যোগ্য register হতো (যেমন ভুল layout-এর BSRR এখানে আসল ODR-এর ওপর), তাহলে কোনো fault ছাড়াই অন্য register বদলে যেত, আর bug খুঁজতে দিন লেগে যেত।

Board-এর বার্তা থেকেই ভুলের ঠিকানায় পৌঁছানো যায়, যদি পড়তে জানেন। bus error: write at ... 0x40010808 বলে কোন ঠিকানায় লেখা হয়েছে; ৭ নম্বর অংশের decoder বা README-র map দেখলে সেটি GPIOA-র IDR. PC=0x0800007E main+0x1E বলে কোন instruction লিখেছে: main function-এর শুরু থেকে 0x1E byte দূরে, অর্থাৎ GPIOA->ODR = ...-এর str. দুটি তথ্য মিলিয়ে প্রশ্নটি দাঁড়ায়: “ODR-এ লিখতে গিয়ে IDR-এর ঠিকানা কেন?” উত্তর struct-এর layout-এ। HardFault-এর stacked frame থেকে PC বের করার পুরো পদ্ধতি পর্ব ৩৮-এ (এমবেডেড debugging).

এই ভুল build-এর সময়েই ধরা যায়। একই struct-এর নিচে দুটি লাইন যোগ করা হলো (bad_assert.c):

_Static_assert(offsetof(GPIO_Bad, IDR) == 0x08, "IDR must be at 0x08");
_Static_assert(offsetof(GPIO_Bad, ODR) == 0x0C, "ODR must be at 0x0C");
~/lab/mmr $ clang --target=thumbv7m-none-eabi -mcpu=cortex-m3 -O2 -c bad_assert.c
bad_assert.c:12:16: error: static assertion failed due to requirement
      '__builtin_offsetof(GPIO_Bad, IDR) == 8': IDR must be at 0x08
bad_assert.c:12:40: note: expression evaluates to '4 == 8'
bad_assert.c:13:16: error: static assertion failed due to requirement
      '__builtin_offsetof(GPIO_Bad, ODR) == 12': ODR must be at 0x0C
bad_assert.c:13:40: note: expression evaluates to '8 == 12'
2 errors generated.

(আউটপুট সংক্ষিপ্ত: Clang প্রতিটি ত্রুটির নিচে উৎসের লাইন আর offsetof macro-র বিস্তারও দেখায়; লম্বা লাইন এখানে ভেঙে লেখা।) '4 == 8' লাইনটিই পুরো রোগনির্ণয়: IDR আছে 4-এ, থাকার কথা 8-এ। কোনো board, কোনো debugger লাগেনি। নিচের stepper-এ পুরো ঘটনা:

1uint32_t DIR;+uint32_t RESERVED0;  /* ঠিক করা */2const uint32_t IDR;3uint32_t ODR;…GPIOA->ODR = 1u << 5;12_Static_assert(offsetof(.., IDR) == 0x08)
Offset আর ফল
DIR
IDR
ODR
ফল
  1. প্রথম member. DIR সবসময় offset 0x00-এ বসে, কারণ struct-এর প্রথম member-এর আগে padding থাকতে পারে না (C standard-এর নিয়ম)। এখানে কোনো ভুল সম্ভব নয়।
  2. ফাঁকা ঘর বাদ. লেখক datasheet-এর 0x04-এর খালি ঘরটি এড়িয়ে গেলেন। Compiler-এর চোখে IDR এখন দ্বিতীয় uint32_t, তাই offset 0x04. কোনো সতর্কবার্তা আসে না, কারণ C-তে এটি সম্পূর্ণ বৈধ struct.
  3. ভুলের ফল. ODR সরে 0x08-এ, অর্থাৎ hardware-এর IDR-এর ওপর। GPIOA->ODR = 1u << 5 লেখে 0x40010808-এ; board-এ bus error, HardFault at main+0x1E. LED জ্বলে না।
  4. Static_assert যোগ. _Static_assert(offsetof(GPIO_Bad, IDR) == 0x08, ...) compile-এর সময় শর্তটি হিসাব করে। Clang জানায় expression evaluates to '4 == 8', আর object file তৈরিই হয় না। ভুল ধরা পড়ল hardware-এ যাওয়ার আগে।
  5. ঠিক করা. uint32_t RESERVED0; ফিরিয়ে দিলে IDR 0x08, ODR 0x0C, BSRR 0x10, sizeof 0x18; সব assert পার হয়। bg_regs.h-এর এই সংস্করণ দিয়েই ৩ নম্বর অংশের regs.c চলেছে আর GPIO PA5 LED ON ছেপেছে।

__I-এর const-ও একই রকম পাহারাদার। কেউ ভুলে ADC-র ফলাফল register মুছতে চাইলেন (ro_write.c, সত্যিকারের run):

~/lab/mmr $ clang ... -c ro_write.c
ro_write.c:6:14: error: cannot assign to non-static data member 'DR' with
      const-qualified type 'const volatile uint32_t' (aka 'const volatile unsigned int')
    6 |     ADC1->DR = 0;
      |     ~~~~~~~~ ^
fw/bg_regs.h:31:19: note: non-static data member 'DR' declared const here
1 error generated.

আরেকটি চেনা ভুল macro-তে। #define UART (UART_TypeDef *)0x40004400u, অর্থাৎ বাইরের বন্ধনী ছাড়া লিখলে UART->DR হয়ে যায় (UART_TypeDef *)(0x40004400u->DR), কারণ -> cast-এর চেয়ে আগে বাঁধে। Clang-এর আসল বার্তা: error: member reference type 'unsigned int' is not a pointer. Macro-র এমন অগ্রাধিকারের ফাঁদ C কোর্সের পর্ব ২৭-এ (Preprocessor আর macro) বিস্তারিত।

পরীক্ষা ও ইন্টারভিউতে: এই ধরনের প্রশ্ন প্রায়ই আসে।

  • ঠিকানা 0x40012408-এ একটি ৩২-bit register-এ 5 লিখুন, C-তে। *(volatile uint32_t *)0x40012408u = 5u;, volatile ছাড়া উত্তর অসম্পূর্ণ।
  • Register struct-এ volatile কোথায় দেবেন? প্রতিটি member-এ (CMSIS-এর ধাঁচ) অথবা pointer-এর লক্ষ্য-টাইপে (volatile GPIO_TypeDef *); না দিলে compiler পড়া বাদ দিতে বা মাপ বদলাতে পারে।
  • GPIOA->ODR-এর ঠিকানা কত, base 0x40010800, ODR offset 0x0C? 0x40010800 + 0x0C = 0x4001080C.
  • struct {uint8_t a; uint32_t b; uint16_t c;}-এর sizeof, ৩২-bit ARM-এ? 12: a 0, b 4 (৩ byte padding), c 8, শেষে ২ byte.
  • Datasheet-এর ফাঁকা ঘর struct-এ কীভাবে লিখবেন, আর কীভাবে নিশ্চিত হবেন? uint32_t RESERVED0; বা RESERVED[n] array; _Static_assert(offsetof(...) == ...) দিয়ে প্রতিটি গুরুত্বপূর্ণ offset যাচাই।

৭ · CMSIS — সব নির্মাতার Cortex-M-এ একই নাম

আপনি যে GPIO_TypeDef, __IO বা SCB->VTOR লিখলেন, এই নামগুলো আপনার বানানো নয়। এগুলো CMSIS-এর (Cortex Microcontroller Software Interface Standard) রীতি, যা ARM তৈরি করেছে যাতে ST, NXP, Nordic বা অন্য যে-কোনো নির্মাতার Cortex-M chip-এ একই অভ্যাসে C লেখা যায়। CMSIS অনেক অংশে ভাগ (DSP library, RTOS interface, debugger-এর অংশ ইত্যাদি); register-এর জন্য দরকারি অংশ CMSIS-Core. তার কাঠামো তিন স্তরে:

স্তরকে লেখেযা থাকেবাজারঘর board-এ
Core header (যেমন core_cm3.h)ARM__I/__O/__IO; SCS-এর NVIC, SysTick, SCB struct; NVIC_EnableIRQ(), SysTick_Config(), __enable_irq()bazarghar.h-এর শেষ অর্ধেক
Device headerchip-নির্মাতাপ্রতিটি peripheral-এর struct, base address, bit-এর নাম, IRQn_Type enumbazarghar.h-এর প্রথম অর্ধেক
System ফাইলchip-নির্মাতাSystemInit(), SystemCoreClock variable, clock সেটআপSystemCoreClock শুধু একটি ধ্রুবক 8 MHz

ARM-এর CMSIS_5-এর core_cm3.h (SPDX লাইসেন্স Apache-2.0) খুললে core অংশের পরিচয় পাবেন। Base ঠিকানাগুলো সেখানে এমন: SCS_BASE = 0xE000E000, SysTick_BASE = SCS_BASE + 0x0010, NVIC_BASE = SCS_BASE + 0x0100, SCB_BASE = SCS_BASE + 0x0D00, আর SCB macro হলো ((SCB_Type *) SCB_BASE), ঠিক এই পর্বের কৌশল। SCB_Type-এর প্রথম member-গুলো CPUID 0x000, ICSR 0x004, VTOR 0x008, AIRCR 0x00C, SCR 0x010, CCR 0x014, তারপর ১২ byte-এর SHP[12] 0x018-এ, যা এই পর্বের board-run-এর offsetof(SCB_Type, SHP) = 24-এর সঙ্গে মেলে। এগুলো Private Peripheral Bus-এর অংশ, তাই সব ARMv7-M chip-এ একই।

Qualifier নিয়ে একটি সূক্ষ্ম কথা। CMSIS 5-এর core_cm3.h-এ __I C-তে volatile const, কিন্তু C++-এ শুধু volatile; আর struct-এর member-এর জন্য আলাদা তিনটি নাম আছে: __IM (volatile const), __OM আর __IOM (দুটিই volatile). নতুন CMSIS-এর struct-এ তাই __IOM uint32_t VTOR; লেখা দেখবেন। বাজারঘর board-এর header আর এই পর্বের bg_regs.h সরল রাখতে শুধু পুরোনো তিনটি নাম ব্যবহার করে। আরেকটি চেনা function SysTick_Config(ticks): এটি ticks − 1 ২৪-bit LOAD register-এ না ধরলে (0xFFFFFF-এর বেশি হলে) কিছু না লিখে 1 ফেরত দেয়, নইলে LOAD, priority, VAL আর CTRL সাজিয়ে 0 দেয়। বাজারঘর board-এ 1 ms-এর জন্য ticks = 8 000 000 ÷ 1000 = 8000, তাই LOAD = 7999, reference lab-এর blink.c-এর মান।

Core header-এর function-গুলোও এই struct-এর ওপর দাঁড়ানো। Reference lab-এর bazarghar.h-এ CMSIS-এর নামেই একটি ছোট সংস্করণ আছে:

static inline void NVIC_EnableIRQ(IRQn_Type n)  { NVIC->ISER[0] = 1u << (uint32_t)n; }
static inline void NVIC_SetPriority(IRQn_Type n, uint32_t prio)
{
    if ((int)n < 0)
        SCB->SHP[((uint32_t)n & 0xFu) - 4u] = (uint8_t)(prio << 4);
    else
        NVIC->IP[(uint32_t)n] = (uint8_t)(prio << 4);
}

এখানে দুটি কৌশল একসাথে। ঋণাত্মক IRQn_Type মানে core-এর নিজের exception: SysTick_IRQn = −1. (uint32_t)(−1) & 0xF = 15, বিয়োগ 4 = 11, তাই লেখা যায় SCB->SHP[11]-এ, যার ঠিকানা এই পর্বের board-run বলেছে 0xE000ED23. ধনাত্মক নম্বর যায় NVIC->IP[n]-এ. আর prio << 4 কারণ board-এ (অনেক আসল Cortex-M3-এর মতো) priority byte-এর শুধু ওপরের ৪ bit কাজ করে (Spec decision 19). ব্যবহারকারী লেখেন শুধু NVIC_SetPriority(SysTick_IRQn, 3); ঠিকানা, byte-এর ঘর আর bit-এর সরানো সব struct আর এই ছোট function-এর ভেতরে লুকানো। ARM-এর আসল core_cm3.h-এর সংস্করণ আরও সাধারণ (কত bit কাজ করে তা __NVIC_PRIO_BITS থেকে নেয়), কিন্তু ভাবনা একই।

Device header হাজার লাইনের হয়, আর কেউ তা হাতে লেখেন না। বেশিরভাগ নির্মাতা প্রতিটি chip-এর জন্য একটি SVD (System View Description) ফাইল দেন: একটি XML, যাতে প্রতিটি peripheral-এর base address, register-এর offset, মাপ, access (read-only কিনা) আর প্রতিটি bit field লেখা। ARM-এর SVDConv-এর মতো tool সেখান থেকে C header বানায়, আর অনেক debugger একই ফাইল দেখে register-কে নাম ধরে দেখায়। তবুও SVD-ও মানুষের লেখা, আর তাতে ভুল পাওয়া যায়; চূড়ান্ত সত্য chip-এর reference manual আর আসল hardware-এর আচরণ।

শেষে একটি দক্ষতা, যা debugging-এ বারবার লাগে: অচেনা একটি ঠিকানা দেখে বলা, এটি কোন register. HardFault-এর বার্তায়, disassembly-তে বা logic-analyzer-এর trace-এ আপনি নাম পাবেন না, শুধু সংখ্যা। নিচের program README-র map থেকে উল্টো দিকে খোঁজে, আর Clang-এর movw/movt জোড়া থেকেও base বের করে:

# ঠিকানা থেকে "কোন peripheral-এর কোন register" — README-র map থেকে
MAP = {  # base: (peripheral, প্রতি 4 byte-এ একটি register)
    0x40004400: ("UART",  ["SR", "DR", "BRR", "CR1"]),
    0x40010800: ("GPIOA", ["DIR", "(ফাঁকা)", "IDR", "ODR", "BSRR", "BRR"]),
    0x40012400: ("ADC1",  ["SR", "CR", "DR"]),
    0xE000E010: ("SysTick", ["CTRL", "LOAD", "VAL", "CALIB"]),
    0xE000ED00: ("SCB",   ["CPUID", "ICSR", "VTOR", "AIRCR", "SCR", "CCR"]),
}

def decode(addr):
    for base, (per, regs) in MAP.items():
        off = addr - base
        if 0 <= off < 4 * len(regs):
            reg = regs[off // 4]
            extra = "" if off % 4 == 0 else f", byte {off % 4}"
            return f"{per}->{reg} (base + 0x{off:02X}{extra})"
    return "map-এ নেই"

# Clang-এর movw/movt জোড়া: নিচের 16 bit আর ওপরের 16 bit
lo, hi = 9216, 16385                    # movw r0, #9216 / movt r0, #16385
base = (hi << 16) | lo
print(f"movw/movt -> 0x{base:08X} = {decode(base)}")
for a in [base + 8, 0x40004408, 0x40010808, 0x4001080D, 0xE000ED08,
          0xE000E014, 0x40010818]:
    print(f"0x{a:08X} -> {decode(a)}")

আসল আউটপুট (ব্রাউজারের Python):

movw/movt -> 0x40012400 = ADC1->SR (base + 0x00)
0x40012408 -> ADC1->DR (base + 0x08)
0x40004408 -> UART->BRR (base + 0x08)
0x40010808 -> GPIOA->IDR (base + 0x08)
0x4001080D -> GPIOA->ODR (base + 0x0D, byte 1)
0xE000ED08 -> SCB->VTOR (base + 0x08)
0xE000E014 -> SysTick->LOAD (base + 0x04)
0x40010818 -> map-এ নেই

তৃতীয় লাইনটি ৬ নম্বর অংশের HardFault-এর ঠিকানা: 0x40010808 হলো IDR, যেখানে ভুল struct ODR ভেবে লিখেছিল। চতুর্থটি একটি byte access-এর ঠিকানা: ODR-এর দ্বিতীয় byte (bit 8–15), যা uint8_t member বা ldrb/strb থেকে আসতে পারে। শেষেরটি GPIOA-র ছয় register-এর পরের ঠিকানা; board-এ তা bus error দেবে।

আরও গভীরে: Register struct C-র একটি “বাস্তব চুক্তি”, standard-এর প্রতিশ্রুতি নয়। পূর্ণসংখ্যাকে pointer-এ রূপান্তর C11-এ implementation-defined (৬.৩.২.৩ অংশ), আর member-এর মাঝে padding কতটা হবে তাও implementation-এর ব্যাপার; Cortex-M-এ সেই implementation বেঁধে দেয় ARM-এর AAPCS, যা সব প্রধান compiler মানে। তাই offset-এর _Static_assert কোনো বাড়তি সাবধানতা নয়, চুক্তিটি যে সত্যিই মানা হচ্ছে তার প্রমাণ। Cortex-M3-এর bit-band region (পর্ব ২৯) একটি ভিন্ন পথও দেয়: peripheral region-এর প্রতিটি bit-এর জন্য আলাদা একটি word-ঠিকানা, যেখানে লিখলে শুধু সেই bit বদলায় (bit-banding; বাজারঘর board এটি model করে না)। আর Linux kernel-এর মতো বড় system-এ driver প্রায়ই struct overlay না করে readl(base + OFFSET)-ধাঁচের accessor ব্যবহার করে, যাতে barrier আর byte-order-এর নিয়ম এক জায়গায় থাকে।

৮ · AI-এর যুগে — register-এর code যাচাই

AI assistant register struct আর macro-র কাঠামো চমৎকার লেখে, কারণ ইন্টারনেটে হাজারো CMSIS header আছে। কিন্তু ঠিক সেই কারণেই সে এক chip-এর ঠিকানা আরেক chip-এ বসায়, বা আত্মবিশ্বাসের সঙ্গে এমন register-এর নাম বানায় যা আপনার chip-এ নেই। এই পর্বের বিষয়ে চোখে পড়ার মতো ভুল:

AI-এর সাধারণ ভুলকীভাবে ধরবেন
একটি STM32-এর peripheral ঠিকানা বা register-এর নাম অন্য chip-এ (বা অন্য STM32 পরিবারে) চালানোনিজের chip-এর অংশ-নম্বরের reference manual আর SVD; ঠিকানা উল্টো দিকে decode করা
Register struct-এ volatile না দেওয়া, বা শুধু pointer variable-কে volatile করা (GPIO_TypeDef * volatile p)-O2 -S-এ polling loop-এ প্রতি পাকে ldr আছে কি না দেখা
Datasheet-এর ফাঁকা ঘর বাদ দেওয়া, বা RESERVED array-র মাপ ভুল গোনাপ্রতিটি register-এর জন্য _Static_assert(offsetof(...))
Register-এর মাপ ভুল টাইপে (৩২-bit register-কে uint16_t বা uint8_t)datasheet-এর access width; disassembly-তে ldr/ldrh/ldrb
Read-only register-এ লেখা বা read-to-clear register “শুধু দেখার জন্য” পড়া__I দিয়ে compiler-কে পাহারায় বসানো; simulator-এ পার্শ্বফল দেখা
Base-macro-তে বাইরের বন্ধনী বাদ, বা integer-pointer cast-এ u/টাইপ ভুলcompile করে দেখা; -Wall -Wextra -Werror
CMSIS-এর function-এর আচরণ বানিয়ে বলা (যেমন SysTick_Config কী ফেরত দেয়)ARM-এর নিজের core_cm3.h-এর code পড়া

AI-কে দিয়ে register header লেখাতে চাইলে register map নিজে দিন, আর যাচাইয়ের ব্যবস্থাও চেয়ে নিন:

আমার microcontroller Cortex-M3. নিচের register map আমি chip-এর reference manual থেকে নিয়েছি, তুমি কোনো ঠিকানা বা offset বদলাবে না বা যোগ করবে না: ADC1 base 0x40012400: SR 0x00 (EOC bit 1), CR 0x04 (ADON bit 0, SWSTART bit 1), DR 0x08 (read-only, পড়লে EOC মোছে)। ১. CMSIS-ধাঁচে একটি C11 struct লেখো, প্রতিটি member-এ __I/__O/__IO, দরকার হলে RESERVED. ২. প্রতিটি offset আর sizeof-এর জন্য _Static_assert লেখো। ৩. base address-এর macro লেখো, বাইরের বন্ধনী সহ। ৪. একটি adc_read() function লেখো যা polling করে, আর বলো কেন volatile না থাকলে -O2-এ loop ঝুলে যেতে পারে। ৫. কোনো বিষয়ে নিশ্চিত না হলে “নিশ্চিত নই” লেখো; বানিয়ে কিছু লিখবে না।

AI-এর উত্তর হাতে পেলে — যাচাইয়ের চেকলিস্ট

ভাবনার প্রশ্ন

প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন, তারপর “→ উত্তর” চাপুন।

প্র ০১CMSIS আসার আগে প্রতিটি chip-নির্মাতা নিজের header লিখতেন। ARM কেন register-এর নাম আর struct-এর ধাঁচ মানসম্মত করল, আর তাতে firmware-এর জগতে কী বদলাল?

ARM নিজে chip বানায় না; সে core-এর নকশা license দেয়, আর বহু নির্মাতা তার চারপাশে নিজের peripheral জোড়েন। Cortex-M3 যখন বাজারে আসে (২০০৪–০৫-এর দিকে), প্রতিটি নির্মাতা নিজের রীতিতে header দিতেন: কেউ macro দিয়ে প্রতিটি register, কেউ struct দিয়ে, কেউ SysTick-কে এক নামে, কেউ আরেক নামে। ফলে একটি RTOS-এর port, একটি middleware library বা একটি শিক্ষার বই প্রতিটি chip-এর জন্য আলাদা করে লিখতে হতো, যদিও core অংশটি সবার একই silicon-নকশা।

CMSIS (সাধারণত ২০০৮ সালের দিকে প্রথম প্রকাশ বলা হয়) এই ভাগটিকে স্পষ্ট করল। Core-এর অংশ, যেমন NVIC, SysTick আর SCB, ARM নিজে একবার লেখে, সব নির্মাতা সেই একই header নেন; নির্মাতা লেখেন শুধু নিজের peripheral-এর device header, কিন্তু একই রীতিতে: PPP_TypeDef struct, PPP_BASE macro, __IO qualifier, IRQn_Type enum. এই পর্বের bazarghar.h-ও এই রীতি মেনেছে, তাই এখানে শেখা অভ্যাস STM32 বা অন্য Cortex-M chip-এ সরাসরি কাজে লাগে।

ফল হলো একটি সাধারণ ভাষা। FreeRTOS-এর মতো RTOS-এর Cortex-M port core-এর অংশ নিয়ে কাজ করে, তাই এক port বহু নির্মাতার chip-এ চলে। ARM-এর CMSIS-DSP library সব chip-এ একই। Debugger SVD ফাইল থেকে register-কে নাম ধরে দেখায়। নতুন একজন প্রকৌশলী অন্য নির্মাতার chip-এ গিয়ে SysTick->LOAD দেখেই চিনতে পারেন। CMSIS 5-এর core অংশ Apache-2.0 লাইসেন্সে, তাই বাণিজ্যিক firmware-এও স্বাধীনভাবে ব্যবহার করা যায়।

তবে মানদণ্ড সীমাহীন নয়। Peripheral-এর ভেতরের নকশা প্রতিটি নির্মাতার নিজস্ব: এক নির্মাতার UART-এর register আরেকজনের সঙ্গে মেলে না, শুধু লেখার রীতি মেলে। তাই “CMSIS দিয়ে লেখা” মানে “সব chip-এ চলবে” নয়। Peripheral-এর পার্থক্য ঢাকতে নির্মাতারা আলাদা HAL library দেন, যা আবার নির্মাতা-নির্ভর।

মূল উপলব্ধি: CMSIS core অংশকে সত্যিকারের এক করেছে আর peripheral অংশকে শুধু একই ভাষায় লিখিয়েছে; তাই firmware-এর core-নির্ভর অংশ বহনযোগ্য, peripheral-নির্ভর অংশ নয়।

প্র ০২একই chip-এ একই ধরনের দুটি UART থাকলে register struct কীভাবে একটি driver-কে দুটিতে চালাতে দেয়? আর macro-র পথে কেন তা কঠিন?

STM32-এর মতো chip-এ প্রায়ই তিন-চারটি UART থাকে, আর প্রতিটির register block হুবহু একই: SR, DR, BRR, CR1 একই offset-এ, শুধু base address আলাদা। Register struct-এর সুবিধা এখানেই। Driver function একটি pointer নেয়: void uart_send(UART_TypeDef *u, char c), আর ভেতরে লেখে u->DR = c. ডাকার সময় uart_send(USART1, 'A') বা uart_send(USART2, 'A'): একই code, ভিন্ন base. এই পর্বের Clang output দেখিয়েছে, base একটি register-এ থাকে আর offset instruction-এর ভেতরে ([r0, #8]), তাই base বদলালে code-এর কোনো বাড়তি খরচ নেই।

Macro-র পথে প্রতিটি register-এর ঠিকানা সংখ্যা হিসেবে macro-র ভেতরে গাঁথা: USART1_DR আর USART2_DR দুটি আলাদা নাম। একটি function দুটি UART-এ চালাতে হলে হয় দুটি কপি লিখতে হয়, নয়তো base-কে সংখ্যা হিসেবে পাঠিয়ে হাতে offset যোগ করতে হয়: *(volatile uint32_t *)(base + 4). দ্বিতীয়টি কাজ করে, কিন্তু তখন offset আবার “জাদুর সংখ্যা”, compiler টাইপ দিয়ে কিছুই পাহারা দেয় না: ভুলে GPIO-র base পাঠালেও compile হবে।

Struct pointer-এ টাইপও পাহারা দেয়। uart_send(GPIOA, 'A') লিখলে compiler সতর্ক করে, কারণ GPIO_TypeDef * আর UART_TypeDef * আলাদা টাইপ। বড় firmware-এ এটি অনেক ভুল ধরে। একই কারণে RTOS-এর driver কাঠামো বা নির্মাতাদের HAL library সাধারণত একটি “handle” struct রাখে, যার ভেতরে peripheral-এর pointer থাকে।

এর একটি পরীক্ষাযোগ্য দিক আছে। বাজারঘর board-এ একটিই UART, তাই এই পর্বে দুটি instance দেখানো যায়নি; কিন্তু adc_read_struct আর adc_read_raw-এর assembly হুবহু এক হওয়া প্রমাণ করে যে struct-এর বিমূর্ততা বিনা খরচে আসে। Embedded জগতে একে প্রায়ই “zero-cost abstraction” বলা হয়: পড়তে সহজ, টাইপে নিরাপদ, আর machine code-এ হাতে লেখার সমান।

মূল উপলব্ধি: register struct ঠিকানাকে “base + নামওয়ালা offset”-এ ভাঙে; তাই একই driver একাধিক instance-এ চলে, compiler টাইপ মেলায়, আর code-এর খরচ বাড়ে না।

প্র ০৩C standard কি সত্যিই নিশ্চয়তা দেয় যে একটি struct pointer একটি স্থির ঠিকানার register-এ ঠিকভাবে বসবে? না দিলে লক্ষ লক্ষ firmware কীসের ভরসায় চলে?

সোজা উত্তর: পুরোটা নয়। C11-এর ৬.৩.২.৩ অংশ বলে, একটি পূর্ণসংখ্যাকে pointer-এ রূপান্তরের ফল implementation-defined; অর্থাৎ standard শুধু বলে compiler-কে তার নিয়ম লিখে জানাতে হবে, নিয়মটি কী হবে তা বলে না। Struct-এর ক্ষেত্রে standard নিশ্চয়তা দেয় শুধু কয়েকটি: member-গুলো ঘোষণার ক্রমে বসবে, প্রথম member-এর আগে padding থাকবে না। কিন্তু মাঝে কতটা padding বসবে, তা implementation-এর ব্যাপার। আর volatile access কেমন হবে, সেটিও standard বড় অংশে implementation-এর হাতে ছেড়েছে।

ফাঁকটা পূরণ করে ABI. Cortex-M-এ ARM-এর AAPCS (Procedure Call Standard for the Arm Architecture) প্রতিটি মৌলিক টাইপের মাপ আর alignment বেঁধে দেয়: uint32_t 4 byte, alignment 4. GCC, Clang আর ARM-এর নিজের compiler সবাই এটি মানে, কারণ না মানলে একটির compile করা library আরেকটির code ডাকতে পারত না। তাই একই struct প্রতিটি Cortex-M compiler-এ একই offset পায়। এই পর্বের board-run আর ব্রাউজারের মডেল একই উত্তর দেওয়া এই চুক্তিরই প্রতিফলন। আর integer থেকে pointer রূপান্তরে embedded compiler-গুলো স্বাভাবিক কাজটি করে: সংখ্যাটিই ঠিকানা।

এখানেই _Static_assert-এর আসল মূল্য। এটি “standard বলে” নয়, “এই compiler, এই ABI-তে সত্যিই তাই” কথাটি প্রতিটি build-এ প্রমাণ করে। কেউ যদি ভুল flag দেন (যেমন সব struct-কে packed করার কোনো option), বা header অন্য architecture-এ নিয়ে যান, assert সঙ্গে সঙ্গে চিৎকার করবে। এই পর্বে Clang-এর বার্তা '4 == 8' ঠিক এমন একটি ভুল ধরল, hardware ছোঁয়ার আগেই।

MISRA C-এর মতো নিরাপত্তা-নির্দেশিকা integer-থেকে-pointer রূপান্তরকে সাধারণত সতর্কতার তালিকায় রাখে, তবে hardware access-এর জন্য ব্যতিক্রম যুক্তিসহ লিখে রাখার পথ দেয়। নির্ভরযোগ্যতার নিয়মের পুরো আলোচনা পর্ব ৬৩-এ (নির্ভরযোগ্যতা আর safety), আর অনির্ধারিত আচরণের সাধারণ গল্প C কোর্সের পর্ব ৪৮-এ।

মূল উপলব্ধি: register struct দাঁড়িয়ে আছে C standard, ABI আর compiler-এর তিন-স্তরের চুক্তির ওপর; _Static_assert সেই চুক্তিকে অনুমান থেকে যাচাই করা সত্যে পরিণত করে।

প্র ০৪একটি register পড়লেই কখনো hardware-এর অবস্থা বদলায়। এই “পড়ার পার্শ্বফল” firmware লেখা, logging আর debugging-কে কীভাবে কঠিন করে?

সাধারণ মেমরি পড়া নিরীহ: যতবার খুশি পড়ুন, কিছু বদলায় না। Register-এ তা সত্য নয়। এই পর্বের run-এ ADC-র DR পড়তেই EOC মুছে গেল। UART-এর DR পড়লে receive-এর সারি থেকে একটি byte সরে যায় (Spec decision 24), তাই দ্বিতীয়বার পড়লে পরের byte বা শূন্য আসে। আসল chip-এ অনেক status flag “পড়ে তারপর লিখে মোছা” ধরনের, আর কিছু counter পড়লেই শূন্য হয়।

এর একটি অপ্রত্যাশিত শিকার struct-এর কপি। কেউ logging-এর জন্য লিখলেন ADC_TypeDef snap = *ADC1;, ভেবে যে শুধু একটি ছবি তোলা হলো। কিন্তু struct কপি মানে প্রতিটি member পড়া, DR-সহ। এই পর্বের lab-এ তা চালানো হলো (150 g রেখে, রূপান্তর শুরুর পরে): snap.SR = 2, snap.DR = 505, তারপর ADC1->SR now = 0. এরপর আসল while loop EOC-এর জন্য চিরকাল অপেক্ষা করল, আর run থামল cycle-সীমায়। একটি নিরীহ-দেখতে লাইন ADC-র ফল “চুরি” করে নিল।

Debugger-ও একই ফাঁদে পড়তে পারে। একটি peripheral-এর register view খোলা থাকলে debugger প্রতিবার থামার সময় register-গুলো পড়ে দেখায়; read-to-clear flag থাকলে debugger নিজেই তা মুছে ফেলে, আর program-এর আচরণ debugger-ছাড়া চলার চেয়ে আলাদা হয়। এজন্য SVD ফাইলে register-এর পড়ার পার্শ্বফল চিহ্নিত করার ব্যবস্থা আছে, যাতে ভালো debugger সেগুলো নিজে থেকে না পড়ে। Debugging-এর এই ধরনের সূক্ষ্মতা পর্ব ৩৮-এ (এমবেডেড debugging) আরও আসবে।

নিয়ম তাই কয়েকটি। Read-to-clear register একবার পড়ে মান একটি local variable-এ রাখুন, তারপর সেটি নিয়ে কাজ করুন। পুরো register block কখনো কপি করবেন না। Logging-এ শুধু নিরীহ register (যেমন CR বা BRR) পড়ুন। আর __I দিয়ে অন্তত লেখার ভুল compiler-কে ধরতে দিন।

মূল উপলব্ধি: register-এর পড়া একটি কাজ, শুধু দেখা নয়; কখন, কতবার আর কে পড়ছে, তা নকশার অংশ।

প্র ০৫8085-এর IN/OUT থেকে Cortex-M-এর memory-mapped register পর্যন্ত যাত্রায় কী লাভ হলো, আর কী নতুন ঝুঁকি এল?

8085 আর 8086-এ I/O-র জন্য আলাদা ঠিকানা-জগৎ ছিল: IN আর OUT instruction, 8085-এ ২৫৬টি ৮-bit port, আর IO/M̅ সংকেত দিয়ে বোঝানো হতো access-টি মেমরির না I/O-র। এর সুবিধা ছিল স্পষ্টতা: I/O-র access দেখলেই চেনা যেত, আর ভুল pointer কখনো port-এ লিখতে পারত না। অসুবিধাও ছিল: শুধু accumulator দিয়ে I/O, মেমরির শক্তিশালী addressing mode I/O-তে খাটে না। একই যুগেও অনেক নকশা memory-mapped I/O নিত, যেমন পর্ব ২৩-এ দেখেছেন।

ARM শুরু থেকেই memory-mapped পথ নিয়েছে: ARM-এ আলাদা I/O instruction নেই। ফলে সাধারণ ldr/str, সব addressing mode আর C-র সব pointer-কৌশল register-এ খাটে। এই পর্বের পুরো কাঠামো, struct overlay, base + offset, এক driver বহু instance, এই সিদ্ধান্তের ফল। Compiler-কে আলাদা কোনো ভাষা-বিস্তার শেখাতে হয়নি; volatile আর একটি cast-ই যথেষ্ট।

কিন্তু নতুন ঝুঁকিও এল। প্রথমত, একটি বেপরোয়া pointer এখন hardware-এর register-এ লিখতে পারে: array-র সীমা পার হওয়া একটি লেখা হয়তো GPIO বা watchdog-এর register বদলে দিল। তাই ARMv7-M-এ peripheral region-কে execute-never করা, MPU দিয়ে ঠিকানা-সীমা পাহারা দেওয়া, আর বাজারঘর board-এর মতো ভুল ঠিকানায় bus error দেওয়া জরুরি সুরক্ষা। দ্বিতীয়ত, compiler এখন register-কে সাধারণ মেমরি ভেবে optimize করতে পারে; volatile ভুলে গেলে কী হয়, Clang-এর ldrb আর অসীম loop দেখিয়েছে। তৃতীয়ত, CPU-র ভেতরের write buffer বা bus-এর বিন্যাসের কারণে register-এ লেখা কখন সত্যিই পৌঁছাল, তা নিয়ে সূক্ষ্ম প্রশ্ন ওঠে; বড় chip-এ এজন্য DSB-এর মতো barrier instruction লাগে।

আধুনিক desktop-ও একই পথে গেছে: x86-এ IN/OUT এখনো আছে, কিন্তু PCIe device-এর register প্রায় সব memory-mapped, আর operating system সেগুলো virtual memory-তে map করে। I/O ঠিকানার তাত্ত্বিক দিক Computer Architecture কোর্সের পর্ব ৫১-এ (I/O আর bus).

মূল উপলব্ধি: memory-mapped register C-র পুরো শক্তি hardware-এ এনেছে, কিন্তু সেই সঙ্গে ভুল pointer আর অতি-চতুর compiler-এর ঝুঁকিও; volatile, struct-এর যাচাই আর hardware-এর ঠিকানা-পাহারা মিলেই নিরাপত্তা।

অনুশীলন

প্রথমে নিজে লিখুন বা হিসাব করুন, তারপর উত্তর খুলুন। প্রতিটি উত্তর আসল build আর board-run-এ মেলানো।

  1. নকশা: cold-room sensor-এর bus-এর register struct. বাজারঘর board-এর I2C-ধাঁচের bus-এর base 0x40005400; register: CR 0x00 (শুধু লেখা, bit 0 START), SR 0x04 (শুধু পড়া, bit 0 DONE, bit 1 NACK), ADDR 0x08, REG 0x0C, DATA 0x10 (শুধু পড়া, ১৬-bit ফল)। CMSIS-ধাঁচে struct, offset-পরীক্ষা, base macro আর একটি i2c_read16(addr, reg) function লিখুন, যা NACK হলে −1 দেয়। 4.00 °C-এ address 0x48, register 0 থেকে কী পাবেন, আর 0x49-এ?

    Struct: typedef struct { volatile uint32_t CR; volatile const uint32_t SR; volatile uint32_t ADDR; volatile uint32_t REG; volatile const uint32_t DATA; } I2C_TypeDef; সঙ্গে _Static_assert(offsetof(I2C_TypeDef, SR) == 0x04, ...) আর DATA == 0x10; #define I2C1 ((I2C_TypeDef *)0x40005400u). সব member ৩২-bit, তাই padding নেই।

    Function: I2C1->ADDR = addr; I2C1->REG = reg; I2C1->CR = 1u; while ((I2C1->SR & 1u) == 0) { } if (I2C1->SR & 2u) return -1; return (int32_t)I2C1->DATA;

    আসল run (i2c.c, script-এ 4.00 °C): 0x48 reg 0 DATA = 1024, অর্থাৎ 0x0400: README-র TMP102-ধাঁচের ১২-bit মান বাঁয়ে সরানো, 4.00 °C = 0x0400. শতাংশ-ডিগ্রিতে 400. আর 0x49 -> -1: শুধু 0x48 সাড়া দেয়, অন্য ঠিকানায় NACK (Spec decision 26). ঠিক bus-এর বিস্তারিত আচরণ পর্ব ৫১-এ (I2C).

  2. ভুল খুঁজুন। একজন UART-এর জন্য লিখলেন #define UART (UART_TypeDef *)0x40004400u আর UART->DR = (uint8_t)c;. সঙ্গে struct-এ লিখলেন __I uint32_t DR;, কারণ “DR থেকে তো received byte পড়ি।” দুটি ভুল কী, compiler কী বলবে, আর ঠিক রূপ কী?

    ভুল ১, বন্ধনী: macro বিস্তারে হয় (UART_TypeDef *)0x40004400u->DR; -> cast-এর আগে বাঁধে, তাই একটি unsigned সংখ্যার member খোঁজা হয়। আসল Clang: error: member reference type 'unsigned int' is not a pointer. ঠিক রূপ: #define UART ((UART_TypeDef *)0x40004400u).

    ভুল ২, qualifier: README অনুযায়ী DR-এ লিখলে byte পাঠানো হয়, পড়লে received byte আসে: এটি read/write. __I দিলে UART->DR = c-তে Clang বলবে cannot assign to non-static data member 'DR' with const-qualified type, এই পর্বের ro_write.c-এর মতো। ঠিক রূপ: __IO uint32_t DR;. শিক্ষা: qualifier datasheet-এর access থেকে নিন, নিজের ব্যবহার থেকে নয়।

  3. হিসাব: ঠিকানা বের করুন। বাজারঘর board-এর header ধরে নিচের পাঁচটি ঠিকানা হিসাব করুন: (ক) &GPIOA->BSRR, (খ) &UART->CR1, (গ) &NVIC->ICER[0] (NVIC base 0xE000E100, ICER offset 0x80), (ঘ) &NVIC->IP[1] (IP offset 0x300, প্রতিটি ১ byte), (ঙ) &SCB->SHP[11] (SCB base 0xE000ED00, SHP offset 0x18, প্রতিটি ১ byte).
    1. (ক) 0x40010800 + 0x10 = 0x40010810 (struct-এর offsetof(GPIO_TypeDef, BSRR) == 0x10 assert পার হয়েছে)।
    2. (খ) 0x40004400 + 0x0C = 0x4000440C; regs.c-এর run ঠিক এই ঠিকানা ছেপেছে, মান 0x200C.
    3. (গ) 0xE000E100 + 0x80 = 0xE000E180; board-run: offsetof(NVIC_Type, ICER) = 128 (0x080).
    4. (ঘ) 0xE000E100 + 0x300 + 1 × 1 = 0xE000E401; board-run: 0xE000E000 + 1025 (0x401). এটি IRQ1-এর (UART receive) priority byte.
    5. (ঙ) 0xE000ED00 + 0x18 + 11 = 0xE000ED00 + 0x23 = 0xE000ED23; board-run: 0xE000E000 + 3363 (0xD23). এটি SysTick-এর priority byte.
  4. ফল আগে থেকে বলুন। পাল্লায় 150 g. Firmware ADC চালু করে রূপান্তর শুরু করল (ADC1->CR = 3u;), তারপর logging-এর জন্য লিখল ADC_TypeDef snap = *ADC1;, ছাপল snap.SR, snap.DR আর ADC1->SR, তারপর while ((ADC1->SR & 2u) == 0) { } দিয়ে EOC-র অপেক্ষা করে ফল পড়তে চাইল। বাজারঘর board-এ কী ছাপা হবে, আর শেষে কী ঘটবে?

    আসল run (snap.c):

    UART: snap.SR = 2
    UART: snap.DR = 505
    UART: ADC1->SR now = 0
    UART: waiting for EOC...
    stopped: cycle limit (300000) reached after 300000 cycles

    কেন: struct কপি প্রতিটি member পড়ে। SR পড়ার সময় EOC = 1 (তাই 2), তারপর DR পড়া হলো: 150 g-এ 400 + 0.7 × 150 = 505 count, README-র worked number. কিন্তু DR পড়াই EOC মুছে দিল, তাই ADC1->SR এখন 0. নতুন কোনো রূপান্তর শুরু হয়নি, তাই EOC আর কখনো 1 হবে না: loop চিরকাল ঘোরে। ফলটি ছিল snap.DR-এ, কিন্তু program সেটি দেখেনি। সমাধান: পুরো block কপি না করে শুধু ADC1->CR বা দরকারি নিরীহ register পড়ুন।

নিজেকে যাচাই করুন

ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।

ক্রমএকটি নতুন peripheral-এর জন্য C-তে নিরাপদ register access বানানোর ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. Reference manual থেকে base address, প্রতিটি register-এর offset, মাপ আর access (read-only কিনা) নেওয়া
  2. সেই ক্রমে volatile qualifier আর RESERVED ঘরসহ একটি struct লেখা
  3. প্রতিটি offset আর sizeof-এর জন্য _Static_assert যোগ করা
  4. বাইরের বন্ধনীসহ base address-কে struct pointer-এ cast করা macro লেখা
  5. -> দিয়ে register পড়া-লেখা, আর -S output বা simulator-এ চালিয়ে ঠিকানা ও মান মেলানো

একটি ADC-র ফলাফল register ঠিকানা 0x40012408-এ, ৩২-bit. C-তে সেটি পড়ার সঠিক expression কোনটি?

  • *(uint32_t *)0x40012408u
  • *(volatile uint32_t *)0x40012408u
  • (volatile uint32_t *)0x40012408u
  • *(volatile uint8_t *)0x40012408u

একটি peripheral-এর base 0x40010800; datasheet-এ register: DIR 0x00, (ফাঁকা) 0x04, IDR 0x08, ODR 0x0C. কেউ struct লিখলেন { uint32_t DIR; uint32_t IDR; uint32_t ODR; } (সব volatile). p->ODR-এ লিখলে লেখা কোন ঠিকানায় যাবে?

  • 0x4001080C
  • 0x40010804
  • 0x40010808, অর্থাৎ hardware-এর IDR
  • Compiler ভুল ধরে ফেলবে, তাই লেখা হবে না

৩২-bit ARM-এ (AAPCS) struct { uint8_t CR; uint32_t SR; uint16_t DR; }-এর offsetof(SR) আর sizeof কত?

  • SR 4, sizeof 12
  • SR 1, sizeof 7
  • SR 4, sizeof 10
  • SR 0, sizeof 8

CMSIS-ধাঁচের header-এ __I uint32_t DR; লেখা member-এ কোড ADC1->DR = 0; লিখলে কী হবে?

  • লেখাটি চলবে, কারণ __I মানে volatile
  • শুধু একটি warning আসবে
  • Run-এর সময় HardFault হবে
  • Compile-এর সময় ত্রুটি, কারণ member-টি const

Cortex-M3-এ একটি register struct-এর member থেকে volatile বাদ দিয়ে while ((p->SR & 2u) == 0) { } -Os-এ compile করলে Clang 22 কী code দিতে পারে?

  • প্রতি পাকে ldr দিয়ে SR আবার পড়ে
  • SR একবার (এমনকি ldrb দিয়ে) পড়ে, EOC 0 হলে পড়াহীন অসীম loop
  • Compile ত্রুটি দেয়
  • পুরো loop মুছে সরাসরি DR ফেরত দেয়

CMSIS-এর core header-এ SCB, SysTick আর NVIC-এর ঠিকানা সব নির্মাতার Cortex-M3 chip-এ একই কেন?

  • সব নির্মাতা একই peripheral map ব্যবহার করেন
  • CMSIS header ঠিকানাগুলো নিজে বেছে নেয়
  • এগুলো core-এর অংশ, ARMv7-M-এর System Control Space-এ স্থির ঠিকানায়
  • Linker script ঠিকানাগুলো এক করে দেয়

শব্দকোষ

লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:

মনে রাখুন

  1. Pointer cast: *(volatile uint32_t *)ADDR একটি register; volatile ছাড়া compiler পড়া বাদ দেয় বা মাপ বদলায় (Clang-এ ldrb আর অসীম loop).
  2. Register struct: member-এর ক্রম = register-এর ক্রম, ফাঁকা ঘরে RESERVED; ঠিকানা = base + offsetof; code হাতে লেখা ঠিকানার সমান (ldr r0, [r0, #8]).
  3. যাচাই: প্রতিটি offset আর sizeof-এ _Static_assert; ফাঁকা ঘর ভুললে board-এ 0x40010808-এ bus error আর HardFault, assert থাকলে build-এই '4 == 8'.
  4. Qualifier: __I = volatile const (লেখা compile-ত্রুটি), __O/__IO = volatile; macro-তে বাইরের বন্ধনী।
  5. পড়ার পার্শ্বফল আর CMSIS: DR পড়লে EOC মোছে, block কপি ফল “চুরি” করে; CMSIS core header (SCB, SysTick, NVIC) ARM-এর, device header আর SVD নির্মাতার।

পরের পর্বে: এই পর্বের প্রতিটি firmware এক লাইনে build হয়েছে। পর্দার আড়ালে preprocess, compile, assemble আর link-এর চার ধাপ, target triple, object file, map file আর ELF থেকে binary, সেটি পর্ব ৩৭-এ (Cross-compilation আর build — compiler, linker, map file আর binary).

আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ

এই পর্বটি শেয়ার করুন:
এই পর্বে ভুল পেয়েছেন? জানান