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

Register-এর bit manipulation — set, clear, toggle আর bit field

Bit Manipulation on Registers — Set, Clear, Toggle and Bit Fields

Taught in Bangla, this lesson builds the four register idioms (set, clear, toggle, test) and multi-bit field masks, and shows Clang turning them into ldr, orr/bic/eor/bfi and str on Cortex-M3. On the course's virtual BG-M3 board, a SysTick ISR changing GPIOA ODR during main's read-modify-write loses 26 of 100 alarm updates; BSRR single-store writes or a short PRIMASK critical section lose none. In-page Python models the race at every instruction, and C bit-field structs are checked for hidden RMW risks.

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

  • যেকোনো বিট বা বিটের দলের জন্য mask বানিয়ে set, clear, toggle আর test লেখা, আর Clang-এর আসল Thumb নির্দেশের সঙ্গে মেলানো
  • একাধিক বিটের field-এ shift আর mask macro দিয়ে নিরাপদে মান বসানো আর পড়া
  • Read-modify-write কেন atomic নয়, আর interrupt কোন দুই জায়গায় ঢুকলে update হারায়, আসল run থেকে দেখানো
  • BSRR-ধাঁচের set/reset register আর PRIMASK দিয়ে সমস্যাটি সমাধান করা, দুটির দাম তুলনা করা
  • C bit-field struct register-এর ওপর কেন ঝুঁকিপূর্ণ, compiler-এর output আর board-এর fault দিয়ে ব্যাখ্যা করা

১ · একটি বিট বদলানো কেন বড় ব্যাপার

বাজারঘরের cold room-এর দেয়ালে একটি সুইচবোর্ড কল্পনা করুন: পাশাপাশি ১৬টি সুইচ। একটি সবুজ বাতির, একটি alarm-এর ঘণ্টির, তিনটি একটি ছোট বাতির সারির। দোকানের কর্মচারী শুধু সবুজ বাতি জ্বালাতে চান। তিনি যদি পুরো বোর্ডের একটি “ছবি” মনে রেখে সব সুইচ সেই ছবি মতো আবার বসান, আর এর মধ্যে ম্যানেজার alarm চালু করে থাকেন, তাহলে কর্মচারীর হাতে alarm আবার বন্ধ হয়ে যাবে। অথচ তিনি alarm ছুঁতেই চাননি। এই পর্বের পুরো গল্প এই একটি ছবির মধ্যে।

Microcontroller-এ সুইচবোর্ডের জায়গায় একটি peripheral register, যার প্রতিটি বিট একটি pin বা একটি সেটিং। Register-টি মেমরির একটি নির্দিষ্ট ঠিকানায় বসানো (memory-mapped I/O), তাই C-তে সাধারণ pointer দিয়েই পড়া-লেখা যায়। সমস্যা হলো CPU একবারে পুরো ৩২ বিটের word পড়ে বা লেখে; “শুধু বিট ৫ বদলানো”-র মতো কোনো সাধারণ store নির্দেশ নেই। তাই একটি বিট বদলাতে হয় কৌশলে, আর সেই কৌশলের দুর্বলতা জানতে হয়।

এই পর্বের সব উদাহরণ কোর্সের virtual “বাজারঘর board” BG-M3-এর GPIO port A নিয়ে। মনে রাখুন, এটি কোনো আসল পণ্য নয়: Unicorn-এ একটি আসল ARMv7-M CPU, চারপাশে STM32-ধাঁচের সরল peripheral, আর firmware আসল C, Clang 22.1.8 দিয়ে thumbv7m-এর জন্য compile করা (পর্ব ০৬)। Hex লেখা হবে C-এর ধরনে, যেমন 0x4001080C; binary দেখাতে 0b101. Reference lab-এর README-তে GPIOA-র register map:

Registerঠিকানাকাজপড়া/লেখা
DIR0x40010800বিট = 1 মানে সেই pin outputদুটোই
IDR0x40010808pin-এর আসল অবস্থা (input data)শুধু পড়া
ODR0x4001080Coutput-এর মান (output data)দুটোই
BSRR0x40010810বিট ১৫–০: set; বিট ৩১–১৬: resetশুধু লেখা
BRR0x40010814বিট ১৫–০: resetশুধু লেখা

Pin-গুলো: PA0 button (চাপলে 1), PA5 সবুজ LED, PA6 লাল alarm (README, Spec decision 23: শুধু DIR = 1 এমন pin output চালায় আর log-এ GPIO লাইন দেয়)। এই পর্বে PA8–PA10-কে একটি ৩ বিটের “LED bar” ধরা হবে, যেখানে smart scale দেখাবে প্ল্যাটফর্মে কতটা ভার; board-এ এই তিনটি pin খালি, তাই কোনো অসুবিধা নেই। Register-এর ঠিকানা কীভাবে C struct হয়ে GPIOA->ODR লেখা যায়, তা পরের পর্ব ৩৬ (C-তে memory-mapped register)-এর বিষয়; এখানে শুধু বিটের কাজ।

ছবি ৩৫.১ — GPIOA-র ODR আর BSRR, বিট ধরে

ওপরে ODR-এর ১৬টি বিট আর কোন pin কী; নিচে BSRR-এর দুই অর্ধেক, উদাহরণ মান 0x05000200 (LED bar = 2 বসানো)

GPIOA-র ODR আর BSRR-এর বিট ODR · 0x4001080C 15–11 10 9 8 7 6 5 4 3 2 1 0 PA10–8 bar PA6 alarm PA5 LED PA0 button BSRR · 0x40010810 লেখা = 0x05000200 বিট ৩১–১৬ (BR, 1 = reset) 31–27 1 0 1 0 0 0 0 0 0 0 0 26 25 24 23 22 21 20 19 18 17 16 বিট ১৫–০ (BS, 1 = set) 15–11 0 1 0 0 0 0 0 0 0 0 0 10 9 8 7 6 5 4 3 2 1 0 ODR = (ODR & ~BR) | BS bar = 0b010; 0 লেখা বিট অক্ষত STM32: একই বিটে দুটো 1 হলে set জেতে
ছবি ৩৫.১ — বিট ১০ আর ৮-এ reset, বিট ৯-এ set: একটি store-এ LED bar = 2, আর LED (বিট ৫) বা alarm (বিট ৬)-এ কোনো হাত পড়ে না। Pin-এর অর্থ README-এর board থেকে; PA8–PA10-এর bar এই পর্বের ধরে নেওয়া উদাহরণ।

২ · চারটি মৌলিক কাজ — set, clear, toggle আর test

C-এর &, |, ^, ~, << আর >> operator আপনি C প্রোগ্রামিং পর্ব ০৯-এ শিখেছেন; এখানে আবার শেখানো হবে না। এখানে প্রশ্ন একটাই: register-এ এগুলো কীভাবে ব্যবহার হয়, আর compiler আসলে কী বানায়। সব কাজের শুরু একটি bitmask: এমন একটি সংখ্যা যার শুধু দরকারি বিটগুলো 1. বিট n-এর mask 1u << n; PA5-এর জন্য 1u << 5 = 0x20.

কাজCযুক্তিClang -O2 (Thumb-2)
setODR |= 1u << 5x OR 1 = 1, x OR 0 = xldr, orr #32, str
clearODR &= ~(1u << 5)x AND 0 = 0, x AND 1 = xldr, bic #32, str
toggleODR ^= 1u << 5x XOR 1 = উল্টো, x XOR 0 = xldr, eor #32, str
test(IDR >> 0) & 1uঅন্য সব বিট মুছে একটি রাখাldr, and #1

শেষ কলামটি অনুমান নয়। আমার lab-এ idioms.c নামে একটি ফাইলে প্রতিটি কাজ একটি ছোট function, আর clang -S --target=thumbv7m-none-eabi -mcpu=cortex-m3 -O2 দিয়ে compile করা (Clang 22.1.8, ziglang 0.17.1; .cfi আর directive-এর লাইন বাদ):

led_on:                       @ GPIOA->ODR |= BIT(LED_PIN)
	movw	r0, #2060             @ 0x080C
	movt	r0, #16385            @ 0x4001 -> r0 = 0x4001080C
	ldr	r1, [r0]              @ read
	orr	r1, r1, #32           @ modify: | 0x20
	str	r1, [r0]              @ write
	bx	lr
led_off:                      @ GPIOA->ODR &= ~BIT(LED_PIN)
	...	ldr	r1, [r0]
	bic	r1, r1, #32           @ bit clear: & ~0x20
	str	r1, [r0]
pressed:                      @ (GPIOA->IDR >> BUTTON_PIN) & 1u
	movw	r0, #2056             @ 0x0808 -> IDR
	movt	r0, #16385
	ldr	r0, [r0]
	and	r0, r0, #1
	bx	lr

তিনটি জিনিস লক্ষ করুন। প্রথমত, 1u << 5 হিসাব run-time-এ হয় না; compiler আগেই #32 বানিয়ে ফেলে, তাই macro-তে shift লেখায় কোনো খরচ নেই। দ্বিতীয়ত, clear-এর জন্য ARM-এর আলাদা নির্দেশ আছে, bic (bit clear = AND NOT), তাই ~ আলাদা করে হিসাব হয় না। তৃতীয়ত, ঠিকানা দুটি অর্ধেকে আসে: movw নিচের ১৬ বিট (2060 = 0x080C), movt ওপরের ১৬ বিট (16385 = 0x4001). আর সবচেয়ে জরুরি: set, clear, toggle তিনটিই তিনটি আলাদা নির্দেশ, যার কথা অংশ ৩ আর ৫-এ।

কেন 1 নয়, 1u? C-তে 1 হলো signed int. 1 << 31 ৩২ বিটের int-এ sign বিটে পড়ে, আর C standard অনুযায়ী তা undefined behavior; 1u << 31 নিরাপদে 0x80000000. আর uint8_t-এর মতো ছোট type-এ ~ দিলে আগে int-এ উন্নীত হয় (integer promotion), যার ফাঁদ পর্ব ৩৪-এ। নিয়ম: register-এর mask সবসময় unsigned, আর register-এর type uint32_t.

এবার নিজে চালিয়ে দেখুন। নিচের ছোট মডেল board-এর ODR-এর মতো একটি ১৬ বিটের মান ধরে প্রতিটি কাজের পরে hex আর binary ছাপে; শেষ তিন লাইন BSRR-এর, যার ব্যাখ্যা অংশ ৬-এ:

# বাজারঘর board-এর GPIOA-র ছোট মডেল: ODR-এ set, clear, toggle, test আর BSRR
LED, ALARM, BTN = 5, 6, 0          # PA5 সবুজ LED, PA6 alarm, PA0 button
BAR = 0b111 << 8                   # PA8..PA10: ৩ বিটের LED bar (field)
odr = 0x0000

def show(what):
    print(f"{what:<17} ODR=0x{odr:04X}  {odr:016b}")

def bsrr(v):                       # STM32 নিয়ম: একই বিটে দুটো হলে set জেতে
    global odr
    odr = (odr & ~(v >> 16)) | (v & 0xFFFF)

odr |= 1 << ALARM;            show("set   bit 6")
odr |= 1 << LED;              show("set   bit 5")
odr ^= 1 << LED;              show("toggle bit 5")
odr &= ~(1 << ALARM) & 0xFFFF; show("clear bit 6")
odr = (odr & ~BAR) | ((5 << 8) & BAR);  show("bar = 5 (RMW)")

idr = 0x0001                       # button চাপা থাকলে IDR-এর বিট 0 = 1
print("test  bit 0      ", (idr >> BTN) & 1)

bsrr(1 << LED);               show("BSRR = 0x00000020")
bsrr(1 << (LED + 16));        show("BSRR = 0x00200000")
bsrr((2 << 8) | (BAR << 16)); show("BSRR = 0x07000200")
print("mask 1<<5 =", hex(1 << 5), "  reset 1<<21 =", 1 << 21)

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

set   bit 6       ODR=0x0040  0000000001000000
set   bit 5       ODR=0x0060  0000000001100000
toggle bit 5      ODR=0x0040  0000000001000000
clear bit 6       ODR=0x0000  0000000000000000
bar = 5 (RMW)     ODR=0x0500  0000010100000000
test  bit 0       1
BSRR = 0x00000020 ODR=0x0520  0000010100100000
BSRR = 0x00200000 ODR=0x0500  0000010100000000
BSRR = 0x07000200 ODR=0x0200  0000001000000000
mask 1<<5 = 0x20   reset 1<<21 = 2097152

প্রথম পাঁচটি মান board-এর আসল run-এর সঙ্গে হুবহু মেলে: আমার lab-এর idioms_run.c একই ক্রমে একই কাজ করে প্রতিবার ODR ছাপে, আর সেখানে এসেছে 0x0040, 0x0060, 0x0040, 0x0000, 0x0500. প্রতিটি কাজ শুধু নিজের বিট ছুঁয়েছে, বাকিগুলো যেমন ছিল। শেষ লাইনের 2097152 হলো 0x00200000, যা Clang-এর led_off_bsrr-এ হুবহু mov.w r1, #2097152 হিসেবে আছে।

৩ · Read-modify-write — এক লাইনের C, তিনটি নির্দেশ

GPIOA->ODR |= 1u << 5 দেখতে একটি কাজ, কিন্তু CPU-র কাছে তিনটি: register থেকে পুরো word পড়া, CPU-র ভেতরের একটি register-এ বদলানো, তারপর পুরো word লেখা। এই ধরনটির নাম read-modify-write (RMW). ARM Cortex-M একটি load/store স্থাপত্য (পর্ব ২৯): মেমরিতে সরাসরি হিসাব হয় না, সবকিছু register-এ এনে করতে হয়। তাই RMW এড়ানোর উপায় নেই, যদি না hardware নিজেই অন্য পথ দেয়।

Register-টি যে compiler-এর চোখে “সাধারণ মেমরি” নয়, তা জানানোর দায় volatile-এর: board-এর header-এ প্রতিটি register volatile uint32_t, তাই compiler প্রতিটি পড়া আর লেখা সত্যিই করে, বাদ দেয় না বা জোড়া লাগায় না। কিন্তু volatile পড়া-লেখাকে একসাথে বাঁধে না; RMW-এর তিন ধাপের মাঝে কেউ ঢুকতে পারবে না, এমন কোনো প্রতিশ্রুতি volatile দেয় না। এর বিস্তারিত পর্ব ৩৪-এ। নিচের stepper board-এর আসল run-এর মান ধরে idioms_run.c-এর দ্বিতীয় আর তৃতীয় লাইন দেখায়: alarm আগে থেকেই চালু (ODR = 0x0040), এখন LED চালু, তারপর toggle.

CPU আর GPIOA
চলছে
mask
r0
r1
ODR
pin
  1. শুরু। Alarm আগেই চালু, তাই ODR = 0x0040 (বিট ৬). লক্ষ্য: শুধু বিট ৫ চালু করা। Mask-এর শুরু 1u, unsigned এক।
  2. Mask তৈরি। 1u << 5 = 0x20 = 0b100000. Compiler এটি নিজেই হিসাব করে নির্দেশের ভেতরে #32 বসায়; run-time-এ কোনো shift নির্দেশ নেই।
  3. ঠিকানা। movw r0, #2060 আর movt r0, #16385 মিলে r0 = 0x4001080C, অর্থাৎ ODR. এখনো register-এ কিছু ছোঁয়া হয়নি।
  4. Read. ldr r1, [r0]: পুরো ৩২ বিট CPU-তে আসে, r1 = 0x40. এই মুহূর্তের ছবিটিই পরে লেখা হবে।
  5. Modify. orr r1, r1, #32: r1 = 0x60. খেয়াল করুন, ODR এখনো 0x0040; বদল শুধু CPU-র ভেতরে। এই ফাঁকই অংশ ৫-এর বিপদ।
  6. Write. str r1, [r0]: ODR = 0x0060. Board-এর log-এ 0.0286 ms-এ GPIO PA5 LED ON; alarm-এর বিট ৬ অক্ষত, কারণ পড়া মানেই সেটি ছিল।
  7. Toggle. একই তিন ধাপ, শুধু eor: r1 = 0x60 XOR 0x20 = 0x40, ODR = 0x0040, log-এ 0.0537 ms-এ LED OFF. Set, clear, toggle তিনটিরই গঠন এক: পড়া, বদলানো, লেখা।

একটি প্রশ্ন স্বাভাবিক: বিট ৬ যদি না ছুঁতে চাই, পুরো word লেখা কেন? কারণ ODR-এ লেখার একক ৩২ বিট। Hardware-এর কাছে “শুধু বিট ৫” বলার পথ এই register-এ নেই; তাই আগে পড়ে অন্য বিটগুলো জেনে নিয়ে তাদের আগের মান সমেত লিখতে হয়। যদি কেউ পড়া বাদ দিয়ে সরাসরি GPIOA->ODR = 1u << 5 লেখেন, Clang বানায় শুধু movs r1, #32 আর str: LED চালু হয় ঠিকই, কিন্তু alarm আর LED bar এক ধাক্কায় বন্ধ। নতুনদের সবচেয়ে সাধারণ ভুল এটিই, |=-এর জায়গায় =.

৪ · একাধিক বিটের field — shift আর mask macro

অনেক register-এ কয়েকটি পাশাপাশি বিট মিলে একটি সংখ্যা, যেমন একটি timer-এর prescaler, ADC-এর channel নম্বর বা UART-এর baud-এর ভাগ। একে বলে register field. বাজারঘরের smart scale-এর LED bar ঠিক এমন: PA10–PA8 মিলে ০ থেকে ৭, ভার যত বেশি সংখ্যা তত বড়। Field বসানোর নিয়ম দুই ধাপের: আগে field-এর সব বিট মুছে ফেলা, তারপর নতুন মান সঠিক জায়গায় সরিয়ে OR করা। পড়ার নিয়ম উল্টো: AND দিয়ে field ছেঁকে ডানে সরানো।

এই কাজ প্রতিবার হাতে লিখলে ভুল হয়, তাই firmware-এ ছোট macro রাখা হয়। নামগুলো Linux kernel-এর linux/bitfield.h-এর FIELD_PREP/FIELD_GET-এর ধাঁচে; ST-এর STM32 device header-এও SET_BIT, CLEAR_BIT আর MODIFY_REG নামে একই ধারণার macro আছে। নিচের program host-এ চলে (Wandbox-এর আসল C compiler), কারণ এখানে বিষয় শুধু অঙ্ক:

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

#define BIT(n)                (1u << (n))
#define FIELD_MASK(p, w)      (((1u << (w)) - 1u) << (p))
#define FIELD_GET(r, p, w)    (((r) & FIELD_MASK(p, w)) >> (p))
#define FIELD_SET(r, p, w, v) (((r) & ~FIELD_MASK(p, w)) | \
                               (((uint32_t)(v) << (p)) & FIELD_MASK(p, w)))
#define BAR_POS 8u   /* PA8..PA10: 3-bit LED bar */
#define BAR_W   3u

int main(void)
{
    uint32_t odr = 0x0040;               /* alarm (bit 6) already on */
    odr |= BIT(5);
    printf("set    bit5 : 0x%04X\n", (unsigned)odr);
    printf("test   bit6 : %u\n", (unsigned)((odr >> 6) & 1u));
    odr &= ~BIT(6);
    printf("clear  bit6 : 0x%04X\n", (unsigned)odr);
    printf("mask  w=3,p=8 : 0x%04X\n", FIELD_MASK(BAR_POS, BAR_W));
    odr = FIELD_SET(odr, BAR_POS, BAR_W, 5);
    printf("bar=5       : 0x%04X  bar=%u\n", (unsigned)odr,
           (unsigned)FIELD_GET(odr, BAR_POS, BAR_W));
    odr = FIELD_SET(odr, BAR_POS, BAR_W, 9);   /* 9 does not fit in 3 bits */
    printf("bar=9       : 0x%04X  bar=%u\n", (unsigned)odr,
           (unsigned)FIELD_GET(odr, BAR_POS, BAR_W));
    odr = (odr & ~FIELD_MASK(BAR_POS, BAR_W)) | (9u << BAR_POS); /* no mask */
    printf("bar=9 raw   : 0x%04X  bit11 now %u\n", (unsigned)odr,
           (unsigned)((odr >> 11) & 1u));
    printf("BIT(31)     : 0x%08X\n", BIT(31));
    return 0;
}

আসল আউটপুট:

set    bit5 : 0x0060
test   bit6 : 1
clear  bit6 : 0x0020
mask  w=3,p=8 : 0x0700
bar=5       : 0x0520  bar=5
bar=9       : 0x0120  bar=1
bar=9 raw   : 0x0920  bit11 now 1
BIT(31)     : 0x80000000

FIELD_MASK(8, 3) = (2³ − 1) << 8 = 7 << 8 = 0x0700. মান ৫ বসাতে আগে বিট ১০–৮ মুছে তারপর 0x0500 OR, ফল 0x0520: LED-এর বিট ৫ অক্ষত। এবার শিক্ষার লাইন দুটি। ৯ = 0b1001 তিন বিটে আঁটে না; macro নতুন মানকেও mask করে, তাই শুধু নিচের তিন বিট (0b001) বসে, bar = 1; ভুল মান, কিন্তু অন্তত field-এর বাইরে কিছু নষ্ট হয়নি। Mask ছাড়া লিখলে (“raw”) 9 << 8 = 0x0900, আর বিট ১১, যা field-এর অংশই নয়, চুপচাপ 1 হয়ে গেছে। আসল chip-এ সেই বিট হয়তো অন্য কোনো peripheral-এর সেটিং। তাই নিয়ম: field-এ লেখার আগে মানকেও mask করুন, বা আগে সীমা পরীক্ষা করুন।

Compiler এই macro-কে কী বানায়? idioms.c-এর bar_set() ঠিক RMW-এর field রূপ (ODR পড়া, bar মুছে নতুন মান বসানো, লেখা)। Clang -O2-এর output:

bar_set:                      @ r0 = level
	movw	r1, #2060
	movt	r1, #16385            @ r1 = 0x4001080C (ODR)
	ldr	r2, [r1]              @ read
	bfi	r2, r0, #8, #3        @ modify: r0-এর নিচের 3 বিট r2-এর বিট 10..8-এ
	str	r2, [r1]              @ write
	bx	lr

মোছা, সরানো, mask আর OR, চারটি কাজই Clang একটি নির্দেশে করেছে: BFI (bit field insert), যা ARMv7-M-এর Thumb-2-তে আছে। এটি r0-এর নিচের ৩টি বিট r2-এর বিট ৮ থেকে বসায় আর বাকি বিট ছোঁয় না; field-এর বাইরে যাওয়া বিট নিজেই বাদ পড়ে। তবু কাঠামো সেই একই: ldr, বদল, str. যত চালাক নির্দেশই হোক, register-এ field বসানো RMW-ই থাকে।

মনে রাখার সূত্র

mask = ((1 << w) − 1) << p · বসানো: r = (r & ~mask) | ((v << p) & mask) · পড়া: (r & mask) >> p. এখানে p = field-এর সবচেয়ে নিচের বিট, w = প্রস্থ। Register-এ সবসময় 1u আর uint32_t.

৫ · RMW-এর মাঝখানে interrupt — হারিয়ে যাওয়া update

এবার অংশ ১-এর সুইচবোর্ডের গল্প সত্যি করে দেখা যাক। বাজারঘরের cold room-এর firmware-এ দুটি কাজ একই register ছোঁয়। main loop বারবার সবুজ “সব ঠিক আছে” LED চালু রাখে: GPIOA->ODR |= LED. আর SysTick-এর ISR সময় হলে alarm চালু বা বন্ধ করে, নিজেও RMW দিয়ে। আসল cold room-এ alarm বদলায় অনেক কম, প্রতি ১ s-এর reading-এর পরে; এখানে ভুলটি দ্রুত দেখাতে প্রতি 2 ms-এ একবার বদলানো হয়েছে (ISR প্রতি 1 ms-এ, LOAD = 7999). ISR প্রতিবার দেখে, তার আগের লেখা বিট এখনো আছে কি না; না থাকলে lost বাড়ায়। মূল অংশ (আমার lab-এর race.c):

void SysTick_Handler(void)               /* every 1 ms; acts every 2 ms */
{
    ticks++;
    if (ticks % 2u)
        return;
    if (((GPIOA->ODR & ALARM) != 0u) != (alarm_state != 0u))
        lost++;                          /* someone overwrote our bit */
    alarm_state ^= 1u;
    if (alarm_state)
        GPIOA->ODR |= ALARM;             /* RMW inside the ISR: safe here */
    else
        GPIOA->ODR &= ~ALARM;
    events++;
}
/* main: while (events < 100u) { GPIOA->ODR |= LED; }  then print */

সত্যিকারের run (বাজারঘর board BG-M3, Clang 22.1.8 / ziglang 0.17.1, Unicorn 2.1.4; ১০৪টি লাইনের প্রথম আর শেষ কয়েকটি):

$ python -B board.py run build/race.elf
[     0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[     0.0069 ms] GPIO PA5 LED ON
[     2.0097 ms] GPIO PA6 ALARM ON
[     2.0107 ms] GPIO PA6 ALARM OFF
[     6.0098 ms] GPIO PA6 ALARM ON
[     6.0109 ms] GPIO PA6 ALARM OFF
[    10.0098 ms] GPIO PA6 ALARM ON
[    12.0098 ms] GPIO PA6 ALARM OFF
...
[   200.0435 ms] UART: events=100 lost=26
[   200.0443 ms] exit(0) after 1600354 cycles

2.0097 ms-এ alarm চালু, আর মাত্র 0.0010 ms (৮ cycle) পরে বন্ধ। কেউ বন্ধ করতে বলেনি; ISR-এর পরের সিদ্ধান্ত ছিল 4 ms-এ। 10 ms থেকে 12 ms-এর মতো স্বাভাবিক জোড়াও আছে। মোট ১০০টি বদলের ২৬টি হারিয়েছে। Clang-এর output-এ main-এর loop দেখলে কারণ পরিষ্কার: compiler loop-টি চারবার unroll করেছে, আর প্রতিটি অংশ ldr r0, [r5] / orr r0, r0, #32 / str r0, [r5] / ldr r0, [r6] / cmp / bhi, যেখানে r5 = 0x4001080C. ছয়টি নির্দেশের মধ্যে দুটি ফাঁক বিপজ্জনক: ldr-এর পরে আর orr-এর পরে। প্রায় এক-তৃতীয়াংশ; এখানে ২৬%.

কোন মুহূর্তে কী হয়েছিল, তা দেখতে আমার lab-এ একটি ছোট logging script (rmwlog.py) board-এর exception-এ ঢোকা আর ODR-এ লেখা ঘিরে ছাপে; board-এর মডেল বদলায় না:

$ python -B rmwlog.py build/race.elf 3
[     2.0059 ms] SysTick: main stopped before str (after orr) PC=0x08000122 r0=0x20 ODR=0x20
[     2.0097 ms]   ODR <- 0x60 by SysTick_Handler+0x6A
[     2.0107 ms]   ODR <- 0x20 by main+0x3E
...
[     6.0059 ms] SysTick: main stopped before orr (after ldr) PC=0x0800012C r0=0x20 ODR=0x20
[     6.0098 ms]   ODR <- 0x60 by SysTick_Handler+0x6A
[     6.0109 ms]   ODR <- 0x20 by main+0x4C
main, ISR আর ODR
চলছে
main-এর r0
ODR
alarm_state
log
  1. Read. main ODR পড়ে: r0 = 0x20. শুধু LED চালু, alarm বন্ধ, alarm_state = 0. এটিই main-এর “ছবি”।
  2. Modify. orr-এর পরে r0 = 0x20 (LED আগেই চালু ছিল, তাই বদল নেই)। PC এখন str-এ, 0x08000122.
  3. Interrupt. 2.0059 ms-এ SysTick-এর সময়। CPU str-এর আগেই থামে আর আট word-এর frame-এ r0 = 0x20 রাখে (পর্ব ৩০-এর stacking).
  4. ISR-এর নিজের RMW. ticks = 2, তাই কাজের পালা: আগের লেখা ঠিক আছে (বিট ৬ = 0, state = 0), state = 1, ODR = 0x20 | 0x40 = 0x60. Log: 2.0097 ms-এ ALARM ON.
  5. ফেরা। Frame থেকে r0 = 0x20 ফেরত আসে। main জানেই না যে মাঝখানে কিছু ঘটেছে; তার হাতে এখনো 2.0059 ms-এর আগের ছবি।
  6. Stale write. str r0, [r5]: ODR = 0x20. Alarm-এর বিট মুছে গেল, log-এ 2.0107 ms-এ ALARM OFF. এটিই lost update.
  7. ধরা পড়া। 4 ms-এ ISR দেখে বিট ৬ = 0, অথচ সে শেষবার 1 লিখেছিল: lost++. আসল cold room-এ এর মানে, গরম ঘরের alarm এক মুহূর্ত বেজে চুপ, আর কেউ জানল না।

এই ধরনের ভুলের সাধারণ নাম race condition: ফল নির্ভর করে দুটি কাজ ঠিক কোন ক্রমে চলল তার ওপর। Thread আর lock-এর জগতে এর তত্ত্ব Operating Systems পর্ব ২২-এ। Microcontroller-এ thread নেই, কিন্তু interrupt আছে, আর ISR ঠিক একটি দ্বিতীয় thread-এর মতো যেকোনো দুই নির্দেশের মাঝে ঢুকতে পারে। আগের প্রতিটি জায়গায় interrupt বসিয়ে ফল দেখার একটি ছোট মডেল:

# main করে ODR |= LED; ISR করে ODR |= ALARM. ISR-কে main-এর প্রতিটি
# নির্দেশের আগে-পরে বসিয়ে দেখা: কোন জায়গায় alarm-এর বিট হারায়?
LED, ALARM = 0x20, 0x40

def ldr(s):   s["r0"] = s["odr"]          # ODR পড়ে register-এ
def orr(s):   s["r0"] |= LED              # register-এ বিট বসানো
def st(s):    s["odr"] = s["r0"]          # পুরো word আবার লেখা
def bsrr(s):  s["odr"] |= LED             # peripheral নিজেই OR করে, এক store
def cpsid(s): s["mask"] = True
def cpsie(s): s["mask"] = False

PROGS = {"RMW":     [ldr, orr, st],
         "BSRR":    [bsrr],
         "PRIMASK": [cpsid, ldr, orr, st, cpsie]}

for name, prog in PROGS.items():
    lost = 0
    print(f"== {name}")
    for k in range(len(prog) + 1):        # ISR আসে নির্দেশ k-এর ঠিক আগে
        s = {"odr": 0x00, "r0": 0, "mask": False}
        pending = False
        for i, op in enumerate(prog + [None]):
            if i == k:
                pending = True
            if pending and not s["mask"]:
                s["odr"] |= ALARM         # ISR চলল
                pending = False
            if op:
                op(s)
        where = prog[k].__name__ if k < len(prog) else "end"
        ok = s["odr"] == LED | ALARM
        lost += not ok
        print(f"  irq before {where:<6} ODR=0x{s['odr']:02X}",
              "ok" if ok else "ALARM LOST")
    print(f"  lost {lost} of {len(prog) + 1}")

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

== RMW
  irq before ldr    ODR=0x60 ok
  irq before orr    ODR=0x20 ALARM LOST
  irq before st     ODR=0x20 ALARM LOST
  irq before end    ODR=0x60 ok
  lost 2 of 4
== BSRR
  irq before bsrr   ODR=0x60 ok
  irq before end    ODR=0x60 ok
  lost 0 of 2
== PRIMASK
  irq before cpsid  ODR=0x60 ok
  irq before ldr    ODR=0x60 ok
  irq before orr    ODR=0x60 ok
  irq before st     ODR=0x60 ok
  irq before cpsie  ODR=0x60 ok
  irq before end    ODR=0x60 ok
  lost 0 of 6

RMW-এ ঠিক দুটি জায়গা মারাত্মক: ldr-এর পরে আর orr-এর পরে, যা board-এর log-এর দুই ঘটনার সঙ্গে মেলে (2 ms-এ “before str”, 6 ms-এ “before orr”). BSRR-এ ভাঙার মতো কোনো ফাঁকই নেই, কারণ কাজটি একটি store. PRIMASK-এ ISR মাঝখানে আসতে চাইলেও cpsie পর্যন্ত অপেক্ষা করে। মডেলটি সময় মাপে না, শুধু ক্রম; কোনটি কতবার ঘটবে তা নির্ভর করে loop-এর গঠন আর interrupt-এর সময়ের ওপর।

কেন এই ভুল মাঠে বিপজ্জনক: board-এ ২৬% হয়েছে কারণ এখানে main অবিরাম শুধু RMW করছিল আর ISR প্রতি 2 ms-এ। আসল firmware-এ RMW হয়তো loop-এর সময়ের হাজার ভাগের এক ভাগ, আর alarm বদলায় দিনে কয়েকবার; তখন ভুলটি হয়তো মাসে একবার ঘটে। Test-এর টেবিলে ধরা পড়ে না, বাজারে পড়ে। তাই নিয়মটি অভিজ্ঞতা দিয়ে নয়, যুক্তি দিয়ে মানতে হয়: ISR আর main যে register বা ভ্যারিয়েবল দুজনেই লেখে, সেখানে main-এর RMW সুরক্ষা ছাড়া চলবে না। একটি সূক্ষ্মতা: ISR-এর নিজের RMW এখানে নিরাপদ, কারণ main ISR-কে থামাতে পারে না; কিন্তু বেশি জরুরি আরেকটি ISR থাকলে সেটিও একই প্রশ্নের মুখে।

৬ · সমাধান — set/reset register আর critical section

Hardware-নির্মাতারা এই সমস্যা বহু আগেই চিনেছিলেন। পর্ব ২৪-এর 8255-এর BSR mode মনে করুন: control register-এ একটি byte লিখে port C-এর একটি মাত্র বিট বদলানো যেত (যেমন 0BH = PC5 = 1), পাশের বিট না ছুঁয়ে। আধুনিক microcontroller-এর উত্তর set/reset register: একটি আলাদা ঠিকানা, যেখানে লেখা 1 মানে “এই বিট বদলাতে হবে”, আর 0 মানে “কিছু করার নেই”। STM32-এর নামে এর পরিচিত রূপ BSRR (bit set/reset register), আর বাজারঘর board-এও তাই আছে।

BSRR-এর নিয়ম: বিট n (০–১৫)-এ 1 লিখলে ODR-এর বিট n = 1; বিট n + 16-এ 1 লিখলে ODR-এর বিট n = 0; বাকি সব বিট যেমন ছিল। ST-এর reference manual-এ আরও একটি কথা আছে: একই বিটে set আর reset দুটোতেই 1 লিখলে set জেতে। BRR (বাজারঘর board-এ 0x40010814) শুধু reset-এর অর্ধেক, বিট ০–১৫-এ। দুটিই write-only register: লেখার জন্য, পড়ার জন্য নয়। কিছু STM32 পরিবারে আলাদা BRR নেই, শুধু BSRR; chip-এর manual দেখে নিন। Clang-এর output-এ পার্থক্য এক নজরে:

led_on_bsrr:                  @ GPIOA->BSRR = BIT(LED_PIN)
	movw	r0, #2064             @ 0x0810 -> BSRR
	movt	r0, #16385
	movs	r1, #32
	str	r1, [r0]              @ একটি store, কোনো পড়া নেই
	bx	lr
led_off_bsrr:                 @ GPIOA->BSRR = BIT(LED_PIN + 16u)
	...	mov.w	r1, #2097152      @ 0x00200000
	str	r1, [r0]

কোনো ldr নেই। পুরোনো ছবি নেওয়াই হয় না, তাই পুরোনো ছবি ফিরিয়ে লেখার প্রশ্নও নেই। একটি store একটি bus-এর লেনদেন, যার মাঝে interrupt ঢুকতে পারে না: কাজটি atomic. বাকি কাজ register-এর hardware নিজে করে, ভেতরে, এক ধাপে। এবার race.c-এর main-এ একটি লাইন বদলে (GPIOA->BSRR = LED;) একই run:

$ python -B board.py run build/race_bsrr.elf
[     0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[     0.0066 ms] GPIO PA5 LED ON
[     2.0097 ms] GPIO PA6 ALARM ON
[     4.0098 ms] GPIO PA6 ALARM OFF
[     6.0098 ms] GPIO PA6 ALARM ON
[     8.0098 ms] GPIO PA6 ALARM OFF
...
[   200.0404 ms] UART: events=100 lost=0
[   200.0411 ms] exit(0) after 1600329 cycles

প্রতি 2 ms-এ একটি নিয়মিত ON বা OFF, ১০০টি ঘটনায় একটিও হারায়নি। Clang এখন loop-এ শুধু str r0, [r5] রেখেছে (r0 = 32 আগেই বসানো, r5 = 0x40010810).

দ্বিতীয় পথ: PRIMASK দিয়ে critical section

সব register-এর set/reset সংস্করণ থাকে না; একটি timer-এর control register বা SRAM-এর একটি ভাগ করা ভ্যারিয়েবলে RMW করতেই হয়। তখন RMW-কে একটি critical section-এ রাখা হয়: কিছুক্ষণ interrupt আটকে রাখা। Cortex-M-এ এর সবচেয়ে সরল উপায় PRIMASK: __disable_irq() (cpsid i) আর __enable_irq() (cpsie i). Clang-এর loop হয় cpsid i, ldr, orr, str, cpsie i, আর board-এর run-এও events=100 lost=0. Board pending interrupt cpsie-র পরেই পরীক্ষা করে (Spec decision 20), তাই অপেক্ষায় থাকা SysTick সঙ্গে সঙ্গে নেওয়া হয়।

উপায়কোথায় চলেদামboard-এ lost
সাধারণ RMWসব জায়গায়interrupt-এ update হারায়২৬ / ১০০
BSRR / BRRযে register-এর set/reset রূপ আছেপ্রায় কিছু নয়; শুধু output-এর বিটে০ / ১০০
PRIMASK (cpsid/cpsie)যেকোনো RMWসেই সময়টুকু সব interrupt দেরি করে; nested থাকলে আগের অবস্থা রেখে ফেরাতে হয়০ / ১০০
Bit-bandingশুধু Cortex-M3/M4-এর নির্দিষ্ট অঞ্চলেবিশেষ ঠিকানা; board-এ মডেল নেইচালানো হয়নি

PRIMASK-এর একটি ফাঁদ: কোনো function যদি নিজে __disable_irq() আর __enable_irq() করে, আর তাকে এমন জায়গা থেকে ডাকা হয় যেখানে interrupt আগে থেকেই বন্ধ ছিল, তাহলে ফেরার সময় সে interrupt চালু করে দেবে, যা ডাকা জায়গার ইচ্ছার উল্টো। তাই অভিজ্ঞ firmware আগে PRIMASK-এর মান পড়ে রাখে (CMSIS-এর __get_PRIMASK()), শেষে সেই মানই ফিরিয়ে দেয়। আর critical section যত ছোট সম্ভব; এর ভেতরের প্রতিটি cycle সব interrupt-এর latency-তে যোগ হয়। Interrupt-এর সঙ্গে ভাগ করা data-র পুরো নকশা পর্ব ৪৩ (Interrupt আর ISR নকশা)-এর বিষয়।

Cortex-M3-এর আরেকটি উত্তর bit-banding: peripheral অঞ্চলের প্রতিটি বিটের নিজের ৩২ বিটের “alias” ঠিকানা, যেখানে লিখলে hardware শুধু সেই বিট বদলায়। সূত্র আর বিস্তারিত পর্ব ২৯-এ; সেই সূত্রে ODR-এর বিট ৫-এর alias হতো 0x42000000 + 0x1080C × 32 + 5 × 4 = 0x42210194. বাজারঘর board bit-banding মডেল করে না, আর পর্ব ২৯-এর run-এ alias-এ লেখায় HardFault হয়েছিল; তাই এখানে চালানো হয়নি। সব Cortex-M-এ bit-banding থাকেও না।

Field-এর জন্য BSRR — একটি সূক্ষ্ম পার্থক্য

BSRR দিয়ে পুরো field একবারে বসানো যায়: বসাতে চাওয়া 1-গুলো নিচের অর্ধেকে, আর field-এর সব বিট ওপরের অর্ধেকে। LED bar = 2-এর জন্য (2u << 8) | (0x7u << 24) = 0x07000200. ST-এর নিয়মে (RM0008 §9.2.5: set জেতে) ফল: বিট ৯ = 1, বিট ১০ আর ৮ = 0. বাজারঘর board-এর মডেল (board.py)-ও Spec decision 23-এ একই নিয়ম মানে। আসল run:

$ python -B board.py run build/idioms_run.elf     (শেষের লাইনগুলো)
[     0.2037 ms] UART: bar=2 both  ODR=0x0200
[     0.2288 ms] UART: bar=5 set   ODR=0x0700
[     0.2536 ms] UART: bar=2 exact ODR=0x0200

প্রথম লাইনে bar = 2, STM32-এর মতোই। তবু লেখাটি একটি ফাঁদ: ফল নির্ভর করছে “একই বিটে দুটো 1 হলে কে জেতে” সেই নিয়মের ওপর, যা অন্য chip-এ আলাদা বা অনির্দিষ্ট হতে পারে; এই কোর্সের board-এর আগের সংস্করণেও reset জিতত, RM0008-এর সঙ্গে মেলাতে তা ঠিক করা হয়েছে। দ্বিতীয় লাইনও শিক্ষার: শুধু set-এ 0x500 লিখলে বিট ৯ মোছে না, তাই ODR = 0x0700, অর্থাৎ bar = 7, 5 নয়। তৃতীয় লাইনের লেখাটি যেকোনো নিয়মে ঠিক চলে: শুধু যে বিটগুলো 0 হবে সেগুলো reset-এ, অর্থাৎ (v << 8) | ((~v & 7u) << 24); v = 2 হলে 0x05000200, ছবি ৩৫.১-এর মান। একই বিটে কখনো দুটো 1 থাকে না, তাই অগ্রাধিকারের নিয়মের ওপর নির্ভর নেই। পোর্টেবল firmware-এর জন্য এটিই ভালো অভ্যাস।

BSRR-এ লেখা আর ODR
BSRR ←
set (15–0)
reset (31–16)
ODR
দেখার মতো
  1. Set. bar = 5 থাকা অবস্থায় (ODR = 0x0500) BSRR-এ 0x20 লেখা: hardware নিজেই বিট ৫ = 1 করে, ODR = 0x0520. CPU কিছু পড়েনি, তাই কোনো পুরোনো ছবি নেই।
  2. Reset. 0x00200000 = বিট ২১ = ১৬ + ৫: বিট ৫ = 0, ODR = 0x0500. Bar-এর বিট ১০ আর ৮ অক্ষত।
  3. Race আর নেই। race_bsrr-এ main-এর কাজ একটি str. ISR তার আগে আসুক বা পরে, ODR-এ ISR-এর বিট টিকে থাকে; board-এ ১০০টির মধ্যে ০টি হারিয়েছে।
  4. দুটো 1 একই বিটে। 0x07000200: বিট ৯-এ set আর reset দুটিই। ST-এর নিয়মে set জেতে, board-ও তাই মানে: আসল run-এ 0x0500 থেকে 0x0200. তবু এটি নির্দিষ্ট hardware-এর নিয়মের ওপর নির্ভর করা লেখা।
  5. পোর্টেবল রূপ। শুধু 0 হওয়ার বিটগুলো reset-এ: (~2 & 7) = 5 → বিট ১০ আর ৮. 0x05000200 লিখলে board-এর run-এ 0x0700 (bar = 7) থেকে 0x0200; STM32-এও একই, কারণ কোনো বিটে দুটো 1 নেই।

আরও গভীরে: একই সমস্যার উত্তর নির্মাতারা ভিন্নভাবে দিয়েছেন। Nordic-এর nRF52-এর GPIO-তে OUTSET আর OUTCLR নামে আলাদা register; Raspberry Pi-এর RP2040-এর datasheet অনুযায়ী প্রায় প্রতিটি peripheral register-এর তিনটি alias ঠিকানা আছে (ঠিকানা + 0x1000-এ লিখলে XOR, + 0x2000-এ set, + 0x3000-এ clear), তাই যেকোনো register-এ atomic বিট-কাজ সম্ভব। পুরোনো AVR-এ (যেমন ATmega328P) নিচের I/O ঠিকানায় SBI/CBI নির্দেশ এক নির্দেশে একটি বিট বদলায়, আর PINx-এ 1 লিখলে PORTx-এর সেই বিট উল্টায়। ARMv7-M-এর LDREX/STREX (exclusive access) SRAM-এর ভ্যারিয়েবলে lock ছাড়া atomic RMW দেয়, কিন্তু peripheral register-এ তা কাজ করবে কি না chip-ভেদে আলাদা, তাই GPIO-র জন্য সাধারণত set/reset register-ই ভরসা।

৭ · C bit-field struct — দেখতে সুন্দর, register-এ ঝুঁকিপূর্ণ

C-তে struct-এর member-এর মাপ বিট ধরে দেওয়া যায়: uint32_t led : 1;. এর নাম bit field (C প্রোগ্রামিং পর্ব ২২)। Register-এর ওপর এমন একটি struct বসিয়ে ODR_BITS->led = 1; লেখা খুব পড়তে সুবিধাজনক, আর কিছু vendor header (যেমন Microchip-এর PIC-এর জন্য LATBbits.LATB0-ধাঁচের নাম) এভাবেই লেখা। কিন্তু register-এ এর চারটি সমস্যা আছে, আর চারটিই compiler-এর output বা board-এর run-এ দেখা গেছে।

typedef struct {
    uint32_t pa0   : 1;
    uint32_t       : 4;      /* PA1..PA4 */
    uint32_t led   : 1;      /* PA5 */
    uint32_t alarm : 1;      /* PA6 */
    uint32_t       : 1;
    uint32_t bar   : 3;      /* PA8..PA10 */
    uint32_t       : 21;
} odr_bits_t;
#define ODR_BITS ((volatile odr_bits_t *)&GPIOA->ODR)

void led_on_bf(void)          { ODR_BITS->led = 1; }
void bar_set_bf(uint32_t lvl) { ODR_BITS->bar = lvl; }

এক, এটিও RMW. Clang 22.1.8-এ led_on_bf হুবহু led_on-এর মতো: ldr, orr #32, str; আর bar_set_bf হুবহু bar_set: ldr, bfi r2, r0, #8, #3, str. সুন্দর নামের নিচে সেই একই তিন ধাপ, একই interrupt-এর ফাঁক; কিন্তু কোডে আর চোখে পড়ে না।

দুই, প্রতিটি field আলাদা RMW. ODR_BITS->led = 1; ODR_BITS->alarm = 1; volatile বলে compiler দুটি জোড়া লাগাতে পারে না:

two_fields:                   two_masks:  (ODR |= (1u << 5) | (1u << 6))
	ldr	r1, [r0]                  ldr	r1, [r0]
	orr	r1, r1, #32               orr	r1, r1, #96
	str	r1, [r0]                  str	r1, [r0]
	ldr	r1, [r0]                  bx	lr
	orr	r1, r1, #64
	str	r1, [r0]
	bx	lr

ছয়টি register-এর কাজ, আর মাঝখানে একটি অন্তর্বর্তী অবস্থা (LED চালু, alarm তখনো বন্ধ), যা বাইরের জগৎ দেখতে পায়। কয়েকটি বিট একসাথে বদলাতে হলে (যেমন একটি motor driver-এর দুই দিকের pin, যাদের একসাথে চালু থাকা নিষেধ), mask দিয়ে এক লেখায় করুন।

তিন, access-এর মাপ type-এর ওপর। একই struct uint8_t দিয়ে লিখলে Clang বানায় ldrb/strb, অর্থাৎ byte-এর access. ARM-এর calling convention (AAPCS) volatile bit-field-কে তার ঘোষিত container-এর মাপে access করতে বলে, তাই compiler ঠিক কাজই করেছে; সমস্যা peripheral-এর দিকে। অনেক peripheral শুধু ৩২ বিটের access মানে; ST-এর STM32F1-এর reference manual GPIO register-কে word হিসেবেই access করতে বলে, যদিও STM32G0-এর মতো নতুন পরিবারে byte access চলে। বাজারঘর board-এ byte-এর লেখা পুরো word লেখা হিসেবে মডেল করা, বাকি byte 0 ধরে, তাই আসল run-এ LED চালু করতে গিয়ে bar মুছে গেছে:

$ python -B board.py run build/bf_run.elf --cycles 200000
[     0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[     0.0034 ms] GPIO PA8 = 1
[     0.0034 ms] GPIO PA10 = 1
[     0.0467 ms] UART: 1: byte-wide bit-field, ODR before = 1280
[     0.0475 ms] GPIO PA5 LED ON
[     0.0475 ms] GPIO PA8 = 0
[     0.0475 ms] GPIO PA10 = 0
[     0.0696 ms] UART:    ODR after = 32
[     0.0944 ms] UART: 2: bit-field on write-only BSRR
[     0.0949 ms] bus error: read at unmapped peripheral address 0x40010810
[     0.0949 ms] HardFault: bus error at PC=0x080000C0 main+0x60
[    25.0000 ms] stopped: cycle limit (200000) reached after 200000 cycles

ODR আগে 1280 = 0x0500 (bar = 5), পরে 32 = 0x0020: LED জ্বলেছে, bar নিভেছে। আসল chip-এ ফল কী হবে তা chip-এর নিয়মের ওপর; board-এর এই আচরণ তার মডেলের, কোনো নির্দিষ্ট chip-এর নয়। শিক্ষাটি সার্বজনীন: register-এর access-এর মাপ datasheet ঠিক করে, আর bit-field-এর type সেটি নীরবে বদলে দিতে পারে।

চার, write-only আর বিশেষ register-এ পড়া। BSRR-এর ওপর bit-field (BSRR_BITS->set_led = 1) compiler-এর কাছে আবার RMW: ldr r1, [r0] যেখানে r0 = 0x40010810. Board-এ BSRR পড়া যায় না, তাই ওপরের run-এ bus error আর HardFault; firmware-এর default handler অসীম loop-এ আটকে, run cycle-এর সীমায় থেমেছে। অনেক আসল chip-এ write-only register পড়লে 0 আসে, তাই কোডটি হয়তো “কাজ করে”, যতক্ষণ না কেউ একই struct দিয়ে দুটি field লেখেন। আরও বিপজ্জনক হলো write-1-to-clear register, যেমন board-এর EXTI-এর PR (Spec decision 27): সেখানে RMW পড়ে আনা প্রতিটি pending 1 আবার লিখে দেয়, আর তাতে এমন interrupt-এর pending মুছে যায় যা আপনি ছুঁতেই চাননি। পঞ্চম একটি কথা C standard-এর: bit-field-এর বিট কোন দিক থেকে সাজানো হবে, তা implementation-defined (C11 §6.7.2.1); ARM-এর AAPCS এটি নির্দিষ্ট করে বলে Cortex-M-এ সমস্যা কম, কিন্তু অন্য compiler বা অন্য স্থাপত্যে একই header ভিন্ন অর্থ দিতে পারে।

পরীক্ষা ও ইন্টারভিউতে: (১) “বিট n set, clear, toggle আর test-এর C লিখুন” → r |= 1u << n, r &= ~(1u << n), r ^= 1u << n, (r >> n) & 1u. (২) “1 << 31-এ সমস্যা কী?” → signed int-এ sign বিটে shift, undefined behavior; 1u লিখুন। (৩) “reg |= mask কি atomic?” → না, load-modify-store; ISR মাঝে ঢুকলে update হারাতে পারে। (৪) “BSRR কেন?” → set/reset এক store-এ, পড়া ছাড়া, তাই atomic আর অন্য বিট অক্ষত। (৫) “Register-এ bit-field struct-এর ঝুঁকি?” → লুকোনো RMW, প্রতি field আলাদা access, access-এর মাপ আর বিটের ক্রম compiler-নির্ভর, write-only/W1C register-এ পড়া।

৮ · AI-এর যুগে register-এর বিট যাচাই

Bit manipulation-এর কোড এত ছোট যে AI assistant এক মুহূর্তে লিখে দেয়, আর বেশিরভাগ সময় compile-ও হয়। ভুলগুলো তাই compile-এর পরের: ভুল বিট, ভুল register, আর interrupt-এর সঙ্গে ভাগাভাগি। সবচেয়ে চেনা ভুলগুলো আর ধরার উপায়:

AI প্রায়ই যা করেকীভাবে ধরবেন
|=-এর জায়গায় = দিয়ে register-এ লেখে, অন্য pin মুছে যায়Clang-এর -S-এ ldr আছে কি না দেখুন; board-এ অন্য pin-এর GPIO লাইন খেয়াল করুন
ISR আর main দুজনের লেখা register-এ সাধারণ RMW রাখেকে কোন register লেখে তার তালিকা করুন; set/reset register বা critical section দিন
নির্দিষ্ট chip-এর register-এর ঠিকানা, বিটের অবস্থান বা BSRR/BRR-এর অস্তিত্ব বানিয়ে বলেChip-এর reference manual আর vendor-এর header মিলিয়ে দেখুন
1 << 31, signed mask, বা field-এ মান mask না করেই বসানো-Wall -Wextra, unsigned mask; সীমার বাইরের মান দিয়ে host-এ পরীক্ষা
& আর ==-এর অগ্রাধিকার গুলিয়ে ফেলেClang-এর -Wparentheses সতর্কবার্তা (অনুশীলন ২)
Register-এর ওপর bit-field struct দেয়, write-only বা W1C register-এওAssembly-তে ldr/ldrb খুঁজুন; register-এর access-এর ধরন datasheet-এ দেখুন

AI-কে কাজে লাগাতে প্রসঙ্গ আর যাচাইয়ের শর্ত শুরুতেই দিন:

আমি ARM Cortex-M3-এর firmware লিখছি (Clang, -O2). GPIO port-এ ODR (0x4001080C), BSRR (0x40010810, বিট 15-0 set, বিট 31-16 reset) আর BRR আছে। ১. PA5-এর LED-এর জন্য on, off, toggle আর PA0-র button test-এর C function দাও; mask unsigned রাখবে। ২. PA8-PA10-এর ৩ বিটের field-এ ০-৭ মান বসানোর function দাও, দুই রকম: ODR-এ RMW, আর BSRR-এ এক store-এ (কোনো বিটে set আর reset দুটোই যেন 1 না হয়)। ৩. SysTick-এর ISR একই port-এর PA6 লেখে। কোন লাইনগুলো race-এর ঝুঁকিতে, আর কেন, Thumb নির্দেশ (ldr/orr/str) দেখিয়ে ব্যাখ্যা করো। ৪. কোনো নির্দিষ্ট chip-এর register বা বিট নিয়ে নিশ্চিত না হলে বলো "নিশ্চিত নই, manual দেখুন"; ঠিকানা বানিয়ে বলবে না। Bit-field struct ব্যবহার করবে না।

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

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

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

প্র ০১8255-এর BSR mode থেকে STM32-এর BSRR, nRF52-এর OUTSET/OUTCLR আর RP2040-এর alias ঠিকানা: hardware-নির্মাতারা বারবার আলাদা set/reset ব্যবস্থা কেন বানিয়েছেন, আর প্রতিটির দাম কী?

সমস্যার মূল একটাই: CPU-র সবচেয়ে ছোট লেখার একক একটি byte বা word, কিন্তু hardware-এর অর্থের একক একটি বিট। Intel-এর 8255-এ port C-এর আটটি বিট প্রায়ই আলাদা আলাদা কাজ করত, যেমন handshake-এর সংকেত বা আলাদা যন্ত্রের enable. পুরো port লিখতে হলে আগে বর্তমান মান জানা দরকার, আর 8085-এর যুগে তা মানে আরও নির্দেশ আর আরও ভুলের সুযোগ। তাই BSR mode: control register-এ একটি byte, যার বিট ৭ = 0 বলে এটি mode নয়, বিট ৩–১ বিটের নম্বর, বিট ০ মান। এক লেখায় একটি বিট, পাশের বিট অক্ষত।

আধুনিক microcontroller-এ সমস্যাটি আরও তীব্র, কারণ এখন একই port-এ ১৬ বা ৩২টি pin, আর interrupt, DMA, RTOS-এর একাধিক task, এমনকি একাধিক core একই port ছোঁয়। STM32-এর BSRR একটি ৩২ বিটের লেখায় যেকোনো সংখ্যক বিট set আর reset করে, আর ST-এর নিয়মে একই বিটে দুটো এলে set জেতে। Nordic আলাদা দুটি ঠিকানা রেখেছে, OUTSET আর OUTCLR, যাতে প্রতিটির অর্থ সরল। RP2040 আরও এক ধাপ এগিয়েছে: datasheet অনুযায়ী প্রায় প্রতিটি peripheral register-এর XOR, set আর clear-এর alias ঠিকানা আছে, তাই যেকোনো register-এর যেকোনো বিট atomic-ভাবে বদলানো যায়, শুধু GPIO নয়। দুটি core থাকায় এটি সেখানে প্রায় অপরিহার্য।

দাম কোথায়? প্রথমত silicon আর ঠিকানার জায়গা: প্রতিটি alias-এর জন্য bus-এর decoding যুক্তি। দ্বিতীয়ত, এই register-গুলো সাধারণত শুধু লেখার; ফলে “এখন কী আছে” জানতে আলাদা register (ODR বা IDR) পড়তে হয়। তৃতীয়ত, নিয়মের সূক্ষ্মতা chip-ভেদে আলাদা: set জেতে কি না, BRR আছে কি না, alias-এর offset কত। তাই একই 0x07000200 লেখার ফল chip-এর নিয়ম জেনেই বলা যায়; পোর্টেবল firmware সেই নির্ভরতাই এড়ায়।

তবু শিল্প এই পথেই গেছে, কারণ বিকল্প, অর্থাৎ প্রতিটি বিট-বদলের চারপাশে interrupt বন্ধ রাখা, latency বাড়ায় আর ভুলে যাওয়া সহজ। Hardware একবার ঠিক করে দিলে হাজারো firmware লেখকের প্রতিটি লাইনে সেই সাবধানতা আর লাগে না।

মূল উপলব্ধি: CPU word লেখে, hardware বিট বোঝে; set/reset register এই ফাঁক hardware-এ ভরাট করে RMW-কে একক store বানায়, আর তার দাম কিছু ঠিকানা, write-only ব্যবহার আর chip-ভেদের নিয়ম।

প্র ০২C bit-field struct register-এর ওপর ঝুঁকিপূর্ণ হলে কিছু vendor-এর header কেন এখনো এভাবে লেখা? কখন এটি গ্রহণযোগ্য, আর কখন একেবারে নয়?

Bit-field-এর সবচেয়ে বড় গুণ পড়ার সুবিধা। LATBbits.LATB0 = 1 বা ODR_BITS->led = 1 পড়ে যেকেউ বোঝেন কী হচ্ছে, অথচ GPIOA->ODR |= 1u << 5-এ “5” কোন pin, তা মনে রাখতে হয়। Microchip-এর ৮ বিটের PIC-এর জগতে এই ধাঁচ বহু বছর ধরে প্রচলিত, কারণ সেখানে compiler একটি নির্দিষ্ট পরিবারের জন্য, register ৮ বিটের, আর chip-এ এক নির্দেশে একটি বিট বদলানোর ব্যবস্থাও আছে; ফলে লুকোনো RMW-এর খরচ আর ঝুঁকি অনেক কম চোখে পড়ে।

সমস্যা শুরু হয় তিন জায়গায়। প্রথম, portability: C standard বিটের ক্রম, container-এর মাপ আর সীমা পেরোনো field-এর আচরণ implementation-এর ওপর ছেড়েছে। ARM-এর AAPCS এগুলো নির্দিষ্ট করায় Cortex-M-এ Clang আর GCC মোটামুটি একমত, কিন্তু header অন্য compiler বা স্থাপত্যে নিয়ে গেলে নিশ্চয়তা নেই। দ্বিতীয়, লুকোনো access: এই পর্বে Clang-এর output দেখিয়েছে প্রতিটি field-লেখা একটি RMW, দুটি field মানে দুটি RMW, আর uint8_t container মানে byte access. তৃতীয়, register-এর ধরন: write-only, write-1-to-clear বা পড়লেই মুছে যায় এমন register-এ RMW শুধু ভুল নয়, ক্ষতিকর। Board-এ BSRR-এর ওপর bit-field সরাসরি HardFault দিয়েছে।

তাই একটি ব্যবহারিক নিয়ম দাঁড়ায়। সাধারণ পড়া-লেখার control register-এ, যেখানে শুধু একটি context লেখে আর access-এর মাপ container-এর সঙ্গে মেলে, bit-field পড়ার সুবিধা দিতে পারে; অনেক দল তবু নিয়ম হিসেবে এড়ায়, যাতে কোড-পর্যালোচনায় RMW চোখে পড়ে। কিন্তু status register, interrupt flag, set/reset register, আর যেকোনো register যা ISR আর main দুজনেই লেখে, সেখানে bit-field একেবারে নয়। CMSIS-ধাঁচের পথ, অর্থাৎ uint32_t register আর নামসহ mask macro (GPIO_ODR_ODR5-এর মতো), একটু লম্বা কিন্তু প্রতিটি access দৃশ্যমান রাখে। Safety-critical কোডের নিয়মগুলোও (MISRA C-ধাঁচের, পর্ব ৬৩) bit-field-এর implementation-নির্ভর দিকগুলো নিয়ে সতর্ক।

মূল উপলব্ধি: Bit-field পড়ার সুবিধা দেয় কিন্তু access লুকায়; register-এ access-ই আসল বিষয়, তাই যেখানে access-এর ধরন বা interrupt-এর ভাগাভাগি জরুরি, সেখানে খোলা mask-ই নিরাপদ।

প্র ০৩Board-এ ১০০টির মধ্যে ২৬টি update হারিয়েছে, কিন্তু আসল যন্ত্রে এমন ভুল হয়তো মাসে একবার ঘটে। কেন এই ধরনের ভুল test-এ ধরা পড়ে না, আর কোন কৌশলে ধরা যায়?

Lost update ঘটতে তিনটি জিনিস একসাথে লাগে: main RMW-এর ঠিক দুটি নির্দেশের ফাঁকে থাকবে, ঠিক তখনই interrupt আসবে, আর ISR সেই register-এরই কোনো বিট বদলাবে। এই পর্বের পরীক্ষায় তিনটিই কৃত্রিমভাবে বাড়ানো হয়েছিল: main অবিরাম শুধু RMW করছিল (ছয় নির্দেশের দুটি ফাঁক বিপজ্জনক), আর ISR প্রতি 2 ms-এ বদলাচ্ছিল। আসল cold-room firmware-এ main-এর loop হয়তো কয়েক হাজার নির্দেশের, যার মধ্যে একটি RMW; আর alarm বদলায় দিনে কয়েকবার। সম্ভাবনা গুণফলে কমে যায়, আর ভুলটি হয়ে ওঠে “একবার দেখা গিয়েছিল, আর হয়নি” ধরনের।

Test-এর টেবিলে এটি ধরা না পড়ার আরেকটি কারণ নির্ধারিত সময়। Lab-এ একই input বারবার দিলে interrupt একই নির্দেশে আসে; ভুলের জায়গায় না এলে কখনোই আসবে না। এই পর্বের board-ও deterministic: একই firmware প্রতিবার ঠিক ২৬টি হারায়। ফাঁকে না পড়লে সেই board-ই প্রতিবার ০ দেখাত।

তাই ধরার পথ পরীক্ষার চেয়ে নকশা আর পর্যালোচনায়। প্রথম কৌশল ভাগাভাগির তালিকা: প্রতিটি register আর ভাগ করা ভ্যারিয়েবলের পাশে লিখে রাখা কে কে লেখে (main, কোন ISR, DMA). একাধিক লেখক থাকলে প্রতিটি লেখা হয় atomic (set/reset register, একক store), নয়তো critical section-এ। দ্বিতীয় কৌশল compiler-এর output পড়া: এই পর্বে Clang-এর -S-এ ldr-orr-str দেখেই ঝুঁকি চেনা গেছে। তৃতীয় কৌশল stress test: interrupt-এর হার কৃত্রিমভাবে বাড়ানো আর RMW-কে tight loop-এ রাখা, ঠিক যেমন race.c করেছে, আর একটি “canary” পরীক্ষা (ISR নিজের আগের লেখা যাচাই করে lost গোনে)। Emulator-এ interrupt-এর সময় একটু একটু সরিয়ে বহুবার চালানোও একটি কৌশল; আসল hardware-এ timer-এর period সামান্য বদলে একই কাজ হয়।

শেষে, static analysis আর কোডিং নিয়মও সাহায্য করে: কিছু tool ISR-এর সঙ্গে ভাগ করা data-র unprotected access খোঁজে, আর অনেক দলের নিয়ম “ISR-এর সঙ্গে ভাগ করা peripheral-এ RMW নিষেধ”।

মূল উপলব্ধি: Race-এর ভুল সম্ভাবনার গুণফলে লুকিয়ে থাকে; test দিয়ে খোঁজার চেয়ে কে কোন register লেখে তার তালিকা, assembly পড়া আর ইচ্ছাকৃত stress দিয়ে নকশাতেই বন্ধ করা কার্যকর।

প্র ০৪BSRR, PRIMASK, bit-banding আর LDREX/STREX: চারটিই RMW-এর সমস্যা মেটায়। বাজারঘরের দুটি device-এর firmware-এ কোনটি কোথায় বেছে নেবেন, আর কেন?

চারটি উপায়ের ক্ষেত্র আলাদা, তাই প্রশ্নটি আসলে “কোন register বা ভ্যারিয়েবল, আর কে কে লেখে”। GPIO-র output pin-এ, যেখানে chip-এ set/reset register আছে, BSRR সবচেয়ে সরল আর সস্তা: একটি store, কোনো interrupt বন্ধ নয়, কোনো latency-র খরচ নয়। Cold-room monitor-এর alarm pin (PA6) আর smart scale-এর LED bar দুটিই এখানে পড়ে। LED bar-এর তিন বিট একসাথে বসাতে অংশ ৬-এর পোর্টেবল রূপ, যা board আর STM32 দুই জায়গায় একই ফল দেয়।

যে register-এর set/reset রূপ নেই, যেমন একটি timer-এর control register বা UART-এর CR1-এর একটি বিট, যা main আর ISR দুজনেই বদলায়, সেখানে PRIMASK দিয়ে ছোট critical section. খরচ হলো সেই কয়েকটি cycle সব interrupt দেরিতে নেওয়া; Cortex-M3-এ কয়েকটি নির্দেশের জন্য তা সাধারণত নগণ্য, কিন্তু critical section-এর ভেতরে কখনো UART-এ ছাপা বা অপেক্ষা রাখবেন না। Nested ব্যবহারের জন্য আগের PRIMASK রেখে ফিরিয়ে দিন। শুধু কিছু interrupt আটকাতে Cortex-M3-এ BASEPRI আছে (নির্দিষ্ট priority-র নিচেরগুলো আটকায়), যা RTOS-গুলো ব্যবহার করে; বাজারঘর board এটি মডেল করে না (Spec decision 19).

Bit-banding Cortex-M3/M4-এ একটি বিটের জন্য atomic লেখা দেয়, set/reset register না থাকলেও, কিন্তু শুধু নির্দিষ্ট দুই অঞ্চলে, আর সব Cortex-M-এ থাকে না; নতুন নকশায় portability কমায়। বাজারঘর board-এ এটি নেই, তাই কোর্সের firmware-এ ব্যবহার করা যাবে না। LDREX/STREX SRAM-এর ভ্যারিয়েবলের জন্য, যেমন একটি counter বা একটি flag-এর বিট যা দুটি ISR বদলায়: STREX ব্যর্থ হলে আবার চেষ্টা, কোনো interrupt বন্ধ নয়। C11-এর stdatomic.h-এর atomic_fetch_or-এর মতো function Cortex-M3-এ compiler সাধারণত এগুলো দিয়েই বানায়; peripheral register-এ এদের ওপর নির্ভর করবেন না।

তাই বাজারঘরের নকশা: pin-এ BSRR; peripheral-এর ভাগ করা control বিটে ছোট PRIMASK critical section; SRAM-এর ভাগ করা flag-এ atomic বা critical section; আর যতটা সম্ভব ভাগাভাগিই কমানো, যেমন ISR শুধু একটি flag দেয় আর পিন বদলায় একমাত্র main. শেষ উপায়টিই সবচেয়ে শক্তিশালী, কারণ লেখক একজন হলে race থাকেই না।

মূল উপলব্ধি: Pin-এ set/reset register, অন্য peripheral বিটে ছোট critical section, SRAM-এ atomic নির্দেশ, আর সবার আগে নকশায় একজন লেখক: সমাধান নির্ভর করে কোন জিনিস আর কে কে তা ছোঁয়।

প্র ০৫সব register “পড়া-লেখা”-র সাধারণ নিয়ম মানে না: কিছু শুধু লেখার, কিছু 1 লিখলে মোছে, কিছু পড়লেই মুছে যায়। এই ধরনগুলোতে RMW কী বিপদ ডেকে আনে, আর datasheet-এ কীভাবে চিনবেন?

Peripheral register মেমরি নয়, একটি যন্ত্রের দরজা; পড়া আর লেখা দুটিই সেখানে ঘটনা। ST-এর reference manual-এ প্রতিটি বিটের পাশে এর ধরন সংক্ষেপে লেখা থাকে, যেমন rw (পড়া-লেখা), r (শুধু পড়া), w (শুধু লেখা), rc_w1 (পড়া যায়, 1 লিখলে মোছে), rc_r (পড়লেই মোছে)। অন্য নির্মাতারাও কোনো না কোনোভাবে একই তথ্য দেন। RMW শুধু rw-এর জন্য নিরাপদ, আর তাও একজন লেখক থাকলে।

Write-only register-এ RMW-এর ফল chip-ভেদে আলাদা: অনেক chip-এ পড়লে 0 আসে, কোথাও আগের লেখা মান, কোথাও bus error. এই পর্বে board-এ BSRR-এর bit-field পড়তে গিয়েই HardFault হয়েছে। Write-1-to-clear (W1C) register-এ বিপদ আরও সূক্ষ্ম। ধরুন একটি interrupt flag register-এ দুটি বিট pending, A আর B, আর আপনি শুধু A মুছতে চান। RMW করলে পড়া মান = A | B, তাতে A-র বিট OR করে লেখা = A | B; দুটিই মুছে গেল, B-এর interrupt হারাল। ঠিক উপায় RMW নয়, শুধু A-র বিট লেখা: EXTI->PR = 1u;, যা কোর্সের পর্ব ৩০-এর অনুশীলনে আর reference-এর button.c-এ ঠিক এভাবেই আছে (board-এর PR W1C, Spec decision 27). Read-to-clear register-এ বিপদ উল্টো দিক থেকে: debugger-এ register দেখলেই বা কোডে অকারণে একবার পড়লেই flag মুছে যায়; কিছু UART-এ status পড়ে তারপর data পড়লে error flag মোছে, এমন ক্রমও থাকে।

এর সঙ্গে আরও কিছু ধরন আছে: toggle-on-write (AVR-এর PINx-এ 1 লেখা), লেখার আগে key লাগে এমন register (board-এর watchdog-এর RLR, যেখানে KR = 0x5555 আগে লিখতে হয়, Spec decision 28; Cortex-M-এর AIRCR-এ 0x05FA), আর কিছু বিট hardware নিজেই বদলায় (status). শেষেরটিতে RMW-এর মাঝে hardware বিট বদলালে আপনার লেখা সেই বদল মুছে দিতে পারে, ISR-এর race-এর মতোই।

অভ্যাস হিসেবে: প্রতিটি নতুন register-এর জন্য datasheet-এ access-এর ধরন দেখুন, W1C আর write-only register-এ শুধু সরাসরি লেখা (=) ব্যবহার করুন, আর |= লেখার আগে নিজেকে জিজ্ঞেস করুন, “পড়া মানটি কি সত্যিই আমি যা লিখেছিলাম?”

মূল উপলব্ধি: RMW ধরে নেয় পড়া মান = আগের লেখা মান; write-only, W1C, read-to-clear আর hardware-বদলানো বিটে এই ধারণা ভাঙে, তাই access-এর ধরন জেনে = আর |=-এর মধ্যে বেছে নিতে হয়।

অনুশীলন

প্রথমে নিজে লিখুন বা হিসাব করুন, তারপর উত্তর খুলুন। প্রতিটি firmware-এর উত্তর কোর্সের virtual বাজারঘর board-এ build করে চালিয়ে আর প্রতিটি হিসাব চালিয়ে যাচাই করা।

  1. নকশা ও বাস্তবায়ন — smart scale-এর LED bar: bar_show(int32_t net_g) লিখুন, যা নিট ওজন থেকে level = net_g / 625 (5000 g-কে আট ভাগ; ৭-এর বেশি হলে ৭, ঋণাত্মক বা ০ হলে ০) বের করে PA8–PA10-এ বসায়, এক store-এ, যাতে ISR-এর লেখা PA6 বা চালু PA5-এর কোনো ক্ষতি না হয়, আর কোনো বিটে set আর reset দুটোই 1 না হয়। 150 g, 1250 g, 500 g, 5000 g আর 0 g-এর পরে ODR কত হবে (PA5 চালু)?
    #define BAR_POS  8u
    #define BAR_MASK (7u << BAR_POS)
    
    static void bar_show(int32_t net_g)
    {
        uint32_t level = net_g <= 0 ? 0u : (uint32_t)net_g / 625u;   /* 5000 g / 8 */
        if (level > 7u)
            level = 7u;
        GPIOA->BSRR = (level << BAR_POS) | ((~level & 7u) << (BAR_POS + 16u));
    }

    সত্যিকারের run (bar.c, DIR = PA5 আর PA8–PA10): net=150 g ODR=32, net=1250 g ODR=544, net=500 g ODR=32, net=5000 g ODR=1824, net=0 g ODR=32, তারপর exit(0) after 1305 cycles. হিসাব: 150 / 625 = 0 → শুধু LED, 32 = 0x0020; 1250 / 625 = 2 → 0x0220 = 544; 500 → 0; 5000 / 625 = 8 → সীমা ৭ → 0x0720 = 1824. 1250 g-এর লেখা = 0x05000200: set-এ বিট ৯, reset-এ বিট ১০ আর ৮, কোনো বিটে দুটো 1 নেই। PA5 প্রতিবার অক্ষত ছিল (board-এর log-এ LED-এর একটিই ON লাইন), আর কোনো ldr না থাকায় ISR-এর PA6-ও নিরাপদ। ঋণাত্মক ওজন (tare-এর পরে প্ল্যাটফর্ম থেকে মাল তুললে) সরাসরি unsigned-এ ভাগ করলে বিশাল সংখ্যা হতো, তাই আগে পরীক্ষা।

  2. ভুল খুঁজুন — দুটি ছোট function: একজন লিখলেন int led_is_on(void) { return (GPIOA->ODR & 1u << LED_PIN == 1) ? 1 : 0; } আর void led_only(void) { GPIOA->ODR = (1u << LED_PIN); }. দুটিতে কী ভুল, compiler কী বলে, আর ঠিক রূপ কী?

    প্রথমটিতে অগ্রাধিকারের ভুল। C-তে << আগে, তারপর ==, তারপর &; তাই লেখাটির মানে ODR & ((1u << 5) == 1) = ODR & 0 = 0, সবসময়। Clang 22.1.8 (-Wall) বলেছে warning: & has lower precedence than ==; == will be evaluated first [-Wparentheses], আর -O2-এর output-এ ODR পড়ার পরে সরাসরি movs r0, #0: volatile বলে পড়া রয়েছে, কিন্তু ফল স্থির 0. ঠিক রূপ: return (GPIOA->ODR >> LED_PIN) & 1u; বা (GPIOA->ODR & (1u << LED_PIN)) != 0u. মনে রাখুন, & mask-এর ফল 0x20, 1 নয়; তাই == 1 বন্ধনী দিয়েও ভুল থাকত। দ্বিতীয়টিতে |=-এর জায়গায় =: Clang বানিয়েছে শুধু movs r1, #32 আর str, কোনো ldr নেই; LED চালু হয় কিন্তু alarm আর LED bar বন্ধ হয়ে যায়। ঠিক রূপ: GPIOA->BSRR = 1u << LED_PIN; (বা |=, যদি কোনো ISR একই port না লেখে)।

  3. হিসাব — আগে বলুন, তারপর মেলান: ODR = 0x0560. পরপর: (ক) ODR ^= 0x0420; (খ) ODR &= ~(7u << 8); (গ) BSRR = 0x00400100; (STM32-এর নিয়ম). প্রতিটির পরে ODR কত, আর কোন কোন pin বদলাল? (ঘ) Cortex-M3-এর bit-band সূত্রে (peripheral alias base 0x42000000, peripheral base 0x40000000) ODR-এর বিট ৫-এর alias ঠিকানা কত?

    (ক) 0x0560 XOR 0x0420 = 0x0140: বিট ১০ (PA10) আর বিট ৫ (LED) উল্টে বন্ধ; bar এখন 0b001, alarm (বিট ৬) চালু আছে। (খ) 7u << 8 = 0x0700, ~ দিলে বিট ১০–৮ শূন্য: 0x0140 & ~0x0700 = 0x0040; PA8 বন্ধ, শুধু alarm বাকি। (গ) 0x00400100: নিচের অর্ধেকে 0x0100 = বিট ৮ set, ওপরের অর্ধেকে 0x0040 = বিট ৬ reset: (0x0040 & ~0x0040) | 0x0100 = 0x0100; alarm বন্ধ, PA8 চালু। (ঘ) offset = 0x4001080C − 0x40000000 = 0x1080C; 0x1080C × 32 = 0x210180; + 5 × 4 = 0x14; alias = 0x42000000 + 0x210180 + 0x14 = 0x42210194. চারটি মানই Python-এ চালিয়ে মেলানো (0x140, 0x40, 0x100, 0x42210194). মনে রাখুন, বাজারঘর board bit-banding মডেল করে না, তাই (ঘ) শুধু হিসাব, board-এ চালানো নয়।

  4. আগে বলুন, তারপর দেখুন — compiler কী বানাবে: Register-এর ওপর bit-field struct দিয়ে ODR_BITS->led = 1; ODR_BITS->alarm = 1; (দুটি ১ বিটের field, struct-টি volatile), আর তুলনায় GPIOA->ODR |= (1u << 5) | (1u << 6);. Cortex-M3-এ Clang -O2 প্রতিটিতে কয়টি ldr আর str দেবে? একই struct uint8_t দিয়ে লিখলে নির্দেশ কী বদলাবে?

    Bit-field-এর রূপে দুটি ldr আর দুটি str: ldr, orr #32, str, তারপর আবার ldr, orr #64, str. Volatile বলে compiler দুটি access জোড়া লাগাতে পারে না, আর প্রতিটি field-লেখা নিজেই একটি RMW. Mask-এর রূপে একটি করে: ldr, orr #96, str (0x60 = 96). দুটিই Clang 22.1.8-এর আসল output (bf2.c). uint8_t দিয়ে লিখলে একই কাজ ldrb/strb দিয়ে হয়: byte-এর access, যা অনেক peripheral-এ অনুমোদিত নয়, আর board-এর মডেলে ওপরের byte-গুলো 0 করে দেয় (অংশ ৭-এর run-এ LED bar মুছে গিয়েছিল)। শিক্ষা: একসাথে কয়েকটি বিট বদলাতে mask, আর register-এর type সবসময় uint32_t.

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

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

ক্রমARM Cortex-M3-এ একটি ৩২ বিটের register-এর ৩ বিটের field-এ RMW দিয়ে নতুন মান বসানোর ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. Field-এর mask বানানো: ((1u << w) − 1u) << p
  2. Register-এর পুরো word CPU-র একটি register-এ পড়া (ldr)
  3. পড়া মান থেকে field-এর বিটগুলো মুছে ফেলা (AND NOT mask)
  4. নতুন মান p ঘর বাঁয়ে সরিয়ে mask করে OR করা
  5. ফলের পুরো word register-এ লেখা (str)

একটি ৩২ বিটের GPIO register-এ (uint32_t, volatile) শুধু বিট ৫ শূন্য করতে হবে, বাকি বিট অক্ষত রেখে। কোন C লাইনটি ঠিক?

  • reg |= (1u << 5);
  • reg &= (1u << 5);
  • reg &= ~(1u << 5);
  • reg ^= (1u << 5);

Cortex-M3-এ GPIOA->ODR |= 0x20; Clang -O2-এ হয় ldr r1, [r0], orr r1, r1, #32, str r1, [r0]. একটি ISR একই ODR-এর বিট ৬ চালু করে। কোন মুহূর্তে interrupt এলে ISR-এর বদল হারিয়ে যায়?

  • শুধু ldr-এর আগে এলে
  • ldr-এর পরে আর str-এর আগে (orr-এর আগে বা পরে)
  • শুধু str-এর পরে এলে
  • কখনোই না, কারণ ODR volatile

STM32-ধাঁচের একটি GPIO port-এর ODR = 0x0060. BSRR-এ 0x00200100 লেখা হলো (বিট ১৫–০ set, বিট ৩১–১৬ reset). নতুন ODR কত?

  • 0x0100
  • 0x0160
  • 0x0040
  • 0x0140

একটি ৩২ বিটের register-এর বিট ১২ থেকে শুরু হওয়া ৪ বিটের field-এর mask কোনটি?

  • 0x0000F000
  • 0x00000F00
  • 0x00001000
  • 0x0001E000

একটি ISR আর main দুজনেই একটি Cortex-M3-এর timer control register-এর ভিন্ন ভিন্ন বিট RMW দিয়ে বদলায়, আর এই register-এর কোনো set/reset রূপ নেই। main-এর দিকে সবচেয়ে সরাসরি নিরাপদ উপায় কোনটি?

  • register-টি volatile ঘোষণা করা
  • RMW-টি __disable_irq() আর __enable_irq()-এর মাঝে রাখা
  • C bit-field struct দিয়ে শুধু নিজের বিট লেখা
  • -O3 দিয়ে compile করা

Cortex-M3-এ volatile register-এর ওপর uint8_t container-এর bit-field struct দিয়ে একটি ১ বিটের field-এ 1 লিখলে Clang সাধারণত কোন ধরনের নির্দেশ বানায়?

  • শুধু একটি str, পড়া ছাড়া
  • ldr, orr, str (৩২ বিটের word)
  • ldrb, orr, strb (byte-এর access)
  • একটি বিশেষ atomic বিট-set নির্দেশ

শব্দকোষ

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

মনে রাখুন

  1. চার কাজ: set |= m, clear &= ~m, toggle ^= m, test (r >> n) & 1u; mask সবসময় unsigned (1u << n), register uint32_t.
  2. Field: mask = ((1u << w) − 1u) << p; বসাতে আগে মুছুন, তারপর মান mask করে OR; Clang একে bfi-তে বানায়, কিন্তু তবু RMW.
  3. RMW atomic নয়: ldr-এর পরে আর str-এর আগে ISR একই register বদলালে সেই বদল হারায়; board-এ ১০০টিতে ২৬টি।
  4. সমাধান: pin-এ BSRR/BRR (এক store, পড়া নেই); অন্যত্র ছোট PRIMASK critical section; BSRR-এ একই বিটে set আর reset দুটো নয়।
  5. Bit-field struct: লুকোনো RMW, প্রতি field আলাদা access, container-এর মাপের access, write-only/W1C register-এ বিপদ; register-এ খোলা mask নিরাপদ।

পরের পর্বে: পর্ব ৩৬ (C-তে memory-mapped register). GPIOA->ODR-এর পেছনের pointer cast আর volatile struct, struct-এর padding offsetof আর static_assert দিয়ে যাচাই, আর CMSIS-ধাঁচের নাম।

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

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