এই পর্বে যা শিখবেন
- Cortex-M3-এর register file আর xPSR-এর বিন্যাস আঁকা, আর প্রতিটি register-এর কাজ এক লাইনে বলা
ADDS/SUBS-এর পরে N, Z, C, V হাতে বের করা, আর সত্যিকারের board run-এর সঙ্গে মেলানো- Clang-এর আসল Thumb-2 assembly পড়া: কোনটি ১৬ বিটের, কোনটি ৩২ বিটের, IT block কী, আর ভাগ কেন গুণে বদলে গেল
- Thread আর Handler mode, privileged আর unprivileged, MSP আর PSP-এর পার্থক্য বোঝা, আর SysTick-এ mode বদলের প্রতিটি ধাপ দেখা
- Bit-band alias ঠিকানা হিসাব করা আর 8086-এর সঙ্গে Cortex-M-এর পরীক্ষার ধাঁচের তুলনা লিখতে পারা
১ · Cortex-M এক নজরে — microcontroller-এর জন্য বানানো ৩২ বিটের core
মডিউল ২ আর ৩-এ আপনি দুটি পুরোনো Intel chip-এর ভেতরে ঘুরে এসেছেন: ৮ বিটের 8085 (পর্ব ০৭) আর ১৬ বিটের 8086 (পর্ব ১৪)। এবার আজকের microcontroller-এর জগৎ। পর্ব ২৮-এ দেখেছেন, AVR, PIC, ESP32-এর পাশাপাশি সবচেয়ে বেশি পরিবারে যে CPU core পাওয়া যায়, তা ARM-এর Cortex-M. এই পর্বে সেই core-এর ভেতরটা খুলে দেখবেন: কোন কোন register, কোন ধাঁচের নির্দেশ, আর CPU কখন কোন “অবস্থায়” থাকে।
উপমা — বাজারঘরের ক্যাশ কাউন্টার: দোকানের ক্যাশিয়ার সারাদিন একই কাজ করেন: মাল মাপা, দাম হিসাব, টাকা নেওয়া। এটি তাঁর “Thread mode”. হঠাৎ কাউন্টারের ঘণ্টা বাজল: মালিক ডাকছেন। ক্যাশিয়ার খাতায় চট করে লিখে রাখেন কোন খদ্দেরের কোন হিসাব কোথায় থেমেছে (stack-এ ৮টি register), তারপর মালিকের কাজ সারেন (“Handler mode”), ফিরে এসে খাতা দেখে ঠিক সেই জায়গা থেকে আবার শুরু করেন। আর তাঁর সামনে ষোলোটি একই মাপের খোপ (register); মাল সরাসরি খোপে রেখে হিসাব হয় না, আগে তাক থেকে খোপে আনতে হয় (load), শেষে আবার তাকে তুলে রাখতে হয় (store).
লেখার নিয়ম এই মডিউল থেকে বদলাচ্ছে: hex এখন C-এর ধাঁচে, শুরুতে 0x দিয়ে (0x08000000, 0x4E2), 8085/8086-এর মতো শেষে H দিয়ে নয়। পূর্বজ্ঞান এক লাইনে: ISA, RISC আর CISC-এর সাধারণ তত্ত্ব Computer Architecture পর্ব ২৫-এ, আর একই ধাঁচের একটি load/store ISA, RISC-V, Computer Architecture পর্ব ২৬-এ। এখানে তত্ত্ব আবার নয়, শুধু Cortex-M-এর নির্দিষ্ট রূপ।
| বৈশিষ্ট্য | 8085 | 8086 | Cortex-M3 |
|---|---|---|---|
| Register-এর চওড়া | ৮ বিট (জোড়ায় ১৬) | ১৬ বিট | ৩২ বিট |
| ঠিকানার জায়গা | 64 KB | 1 MB, segment দিয়ে | 4 GB, সমতল (flat) |
| নির্দেশের দৈর্ঘ্য | ১–৩ byte | ১–৬ byte (prefix ছাড়া) | ২ বা ৪ byte (Thumb-2) |
| মেমরিতে সরাসরি হিসাব | হ্যাঁ (ADD M) | হ্যাঁ (add [bx],ax) | না, শুধু load/store |
| Flag | S Z AC P CY | ৯টি | N Z C V Q (APSR-এ) |
| Interrupt controller | chip-এর ভেতরে ৫টি লাইন | বাইরে 8259 লাগে | core-এর ভেতরে NVIC |
| গুণ-ভাগ | নেই | MUL, DIV | MUL, UMULL, SDIV, UDIV |
ইতিহাসের পাতা থেকে: ARM-এর শুরু ১৯৮৫ সালে, ব্রিটেনের Acorn কম্পিউটারের “Acorn RISC Machine” হিসেবে। নব্বইয়ের দশকে ARM নিজে chip না বানিয়ে নকশা license দেওয়ার পথ নেয়, আর ছোট নির্দেশের Thumb set যোগ করে। পরে ১৬ আর ৩২ বিটের নির্দেশ মেশানো Thumb-2 আসে, আর তার ওপর ভিত্তি করে ARMv7-M architecture আর তার প্রথম core, Cortex-M3, ২০০৪–০৫ সালের দিকে বাজারে আসে। এরপর ছোট Cortex-M0 (ARMv6-M), DSP নির্দেশসহ Cortex-M4, দ্রুত Cortex-M7, আর নিরাপত্তার TrustZone-সহ ARMv8-M-এর Cortex-M33 এসেছে। এই পর্বের নিয়মগুলো মূলত ARM-এর ARMv7-M Architecture Reference Manual আর Cortex-M3 Technical Reference Manual (TRM) থেকে; M0 বা M33-এ কিছু খুঁটিনাটি আলাদা।
এই পর্বের প্রতিটি register-এর মান, flag আর trace এসেছে কোর্সের virtual “বাজারঘর board” BG-M3 থেকে (পর্ব ০৬-এ পরিচয়)। মনে রাখবেন, এটি কোনো আসল পণ্য নয়: Unicorn emulator-এর একটি আসল ARMv7-M CPU, আর তার চারপাশে Python-এ লেখা STM32-ধাঁচের সরল peripheral. Firmware লেখা C-তে, আর compile করা হয়েছে সত্যিকারের Clang 22.1.8 দিয়ে (PyPI-র ziglang 0.17.1, --target=thumbv7m-none-eabi -mcpu=cortex-m3 -O2). এই পর্বের firmware cm3.c প্রথমে core-এর পরিচয়পত্রটাই পড়ে:
$ python -B board.py build firmware/cm3.c -o build/cm3.elf
built build/cm3.elf
$ python -B board.py run build/cm3.elf
[ 0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[ 0.0280 ms] UART: CPUID=0x412FC231
[ 0.0685 ms] UART: net_price(1400, 150) = 8188 paisa
...
[ 1.8215 ms] exit(0) after 14572 cycles
CPUID হলো SCB-র (System Control Block) প্রথম register, ঠিকানা 0xE000ED00. ARMv7-M-এর বিন্যাস অনুযায়ী 0x412FC231 পড়তে হয় এভাবে: 0x41 = নির্মাতা ARM, পরের অঙ্ক 2 = variant (r2), F = architecture-এর ঘর, C23 = part number অর্থাৎ Cortex-M3, শেষ অঙ্ক 1 = revision (p1). মানে board নিজেকে Cortex-M3 r2p1 বলে পরিচয় দেয় (reference lab-এর README-তে এই মানটি লেখা)। আসল chip-এর firmware-ও ঠিক এভাবে বুঝে নিতে পারে, সে কোন core-এ চলছে।
২ · Register file — ষোলোটি ৩২ বিটের ঘর আর কয়েকটি বিশেষ register
Cortex-M3-এর programmer ষোলোটি সাধারণ register দেখেন, R0 থেকে R15, সবগুলো ৩২ বিট চওড়া। এর বাইরে কয়েকটি বিশেষ register আছে, যেগুলো সাধারণ নির্দেশ দিয়ে ছোঁয়া যায় না; পড়তে হয় MRS, লিখতে হয় MSR নির্দেশ দিয়ে। নিচের ছবিতে পুরো চিত্র:
ছবি ২৯.১ — Cortex-M3-এর register আর xPSR-এর বিন্যাস
নীল = সাধারণ register; হলুদ = বিশেষ কাজের R13–R15; বেগুনি = MRS/MSR দিয়ে পড়া বিশেষ register; নিচে xPSR আর CONTROL-এর বিট
| Register | কাজ | মনে রাখার কথা |
|---|---|---|
R0–R3 | function-এর প্রথম চারটি argument; R0-এ ফেরত মান | ডাকা function এগুলো নষ্ট করতে পারে |
R4–R11 | সাধারণ কাজ; local variable | ডাকা function বদলালে আগে stack-এ রেখে শেষে ফিরিয়ে দেয় |
R12 (IP) | অস্থায়ী কাজ | exception-এ hardware নিজেই stack-এ রাখে |
R13 = SP | stack-এর মাথা | আসলে দুটি: MSP আর PSP; নিচের দুই বিট সবসময় 0 |
R14 = LR | BL-এর পরে ফেরার ঠিকানা | exception-এর ভেতরে একটি বিশেষ সংকেত, EXC_RETURN |
R15 = PC | এখন যে নির্দেশ | পড়লে সাধারণত এখনকার ঠিকানা + 4 আসে (pipeline-এর প্রভাব) |
প্রথম দুই সারির নিয়মটি hardware-এর নয়, software-এর চুক্তি: ARM-এর procedure call standard (AAPCS), যা একটি calling convention. Compiler, library আর হাতে লেখা assembly এই চুক্তি মানলেই একে অপরকে ডাকতে পারে। চুক্তির সাধারণ ধারণা আর RISC-V-এ তার রূপ Programming Languages & Compilers পর্ব ৭১-এ; এখানে শুধু Cortex-M-এর রূপটি দেখুন। সব ষোলোটি register-ই general-purpose register-এর মতো দেখতে হলেও R13–R15-এর কাজ বাঁধা।
LR কেন দরকার? 8085 আর 8086-এ CALL ফেরার ঠিকানা সরাসরি stack-এ (মেমরিতে) ঠেলে দিত। Cortex-M-এর BL (branch with link) সেটি রাখে একটি register-এ, LR-এ। যে function আর কাউকে ডাকে না (leaf function), সে stack না ছুঁয়েই BX LR দিয়ে ফিরে যায়: মেমরির একটি লেখা আর একটি পড়া বাঁচে। বাজারঘরের net_price() ঠিক এমন, অংশ ৪-এ দেখবেন। আরেকটি খুঁটিনাটি: LR-এর মান সবসময় বিজোড়, যেমন 0x0800011B. সবচেয়ে নিচের বিট 1 মানে “ফিরে Thumb state-এ চলবে”; আসল ঠিকানা 0x0800011A, কারণ Thumb নির্দেশ সবসময় জোড় ঠিকানায় বসে।
৩ · xPSR — APSR, IPSR আর EPSR, একটি word-এ তিন খবর
xPSR (Program Status Register) আসলে তিনটি register-এর একত্র রূপ, যাদের বিট একে অপরের ওপর পড়ে না। APSR (Application PSR) রাখে শেষ হিসাবের status flag: N (ফল ঋণাত্মক, অর্থাৎ বিট ৩১ = 1), Z (ফল শূন্য), C (carry), V (signed overflow), আর Q (saturating নির্দেশের “sticky” overflow). IPSR (Interrupt PSR) রাখে এখন কোন exception-এর handler চলছে তার নম্বর; সাধারণ কোডে 0. EPSR (Execution PSR) রাখে T বিট আর IT/ICI বিট, যা পরের অংশে।
8086-এর সঙ্গে সবচেয়ে বড় পার্থক্য বিয়োগে। ARM বিয়োগ করে a + NOT b + 1 হিসেবে, আর C হলো সেই যোগের carry. তাই বিয়োগের পরে C = 1 মানে borrow হয়নি (a ≥ b, unsigned অর্থে), আর C = 0 মানে borrow হয়েছে। 8086-এ ঠিক উল্টো: CF = 1 মানে borrow. পরীক্ষায় আর AI-এর উত্তরে এই গোলমাল খুব সাধারণ। আরেকটি পার্থক্য: ARM-এ প্রায় সব নির্দেশ flag ছোঁয় না, যদি না নামের শেষে S থাকে। ADD flag বদলায় না, ADDS বদলায়; CMP শুধু flag বদলায়, ফল কোথাও রাখে না।
cm3.c-তে ছয়টি যোগ-বিয়োগ inline assembly-তে চালিয়ে ঠিক পরেই mrs rX, apsr দিয়ে APSR পড়া হয়েছে। সত্যিকারের run-এর ছয়টি লাইন:
[ 0.1663 ms] UART: adds 0x00000064, 0x00000032 -> 0x00000096 N=0 Z=0 C=0 V=0 APSR=0x00000000
[ 0.2639 ms] UART: adds 0x7FFFFFFF, 0x00000001 -> 0x80000000 N=1 Z=0 C=0 V=1 APSR=0x90000000
[ 0.3615 ms] UART: adds 0xFFFFFFFF, 0x00000001 -> 0x00000000 N=0 Z=1 C=1 V=0 APSR=0x60000000
[ 0.4592 ms] UART: subs 0x000004E2, 0x000004E2 -> 0x00000000 N=0 Z=1 C=1 V=0 APSR=0x60000000
[ 0.5570 ms] UART: subs 0x00000096, 0x00000578 -> 0xFFFFFB1E N=1 Z=0 C=0 V=0 APSR=0x80000000
[ 0.6548 ms] UART: subs 0x80000000, 0x00000001 -> 0x7FFFFFFF N=0 Z=0 C=1 V=1 APSR=0x30000000
| নির্দেশ | |
| ফল | |
| N Z C V | |
| APSR | |
| অর্থ |
- সাধারণ যোগ। 100 + 50 = 150 = 0x96. বিট ৩১ = 0 (N = 0), ফল শূন্য নয় (Z = 0), ৩২ বিট থেকে কিছু বেরোয়নি (C = 0), দুটি ধনাত্মক থেকে ধনাত্মক (V = 0). APSR = 0.
- Signed overflow. 0x7FFFFFFF হলো সবচেয়ে বড় ধনাত্মক int32. তাতে 1 যোগ করলে বিট ৩১ = 1, তাই N = 1, আর দুটি ধনাত্মক থেকে “ঋণাত্মক” ফল: V = 1. Unsigned অর্থে 2147483648 ঠিকই আছে, তাই C = 0. APSR = 0x90000000 = বিট ৩১ আর ২৮.
- Unsigned carry. 0xFFFFFFFF + 1 = 0x1_00000000, ৩৩ বিট। নিচের ৩২ বিট 0 (Z = 1), বেরোনো বিট C-তে (C = 1). Signed অর্থে −1 + 1 = 0 নির্ভুল, তাই V = 0. APSR = 0x60000000.
- সমান দুটি সংখ্যার বিয়োগ। বাজারঘরের 1250 g − 1250 g = 0: Z = 1. আর C = 1, কারণ ARM-এ বিয়োগে C = 1 মানে borrow হয়নি।
CMPঠিক এই হিসাবই করে, ফল না রেখে। - Borrow. 150 − 1400: tare মোট ওজনের চেয়ে বেশি। ফল 0xFFFFFB1E = signed −1250, তাই N = 1. Borrow হয়েছে, তাই C = 0 (8086 হলে CF = 1 হতো)। Signed অর্থে −1250 সীমার ভেতরে, V = 0.
- নিচের দিকে signed overflow. 0x80000000 = −2147483648, সবচেয়ে ছোট int32. তা থেকে 1 বাদ দিলে 0x7FFFFFFF, “ধনাত্মক”: V = 1. Unsigned অর্থে 2147483648 − 1-এ borrow নেই, C = 1. APSR = 0x30000000.
এবার একই নিয়ম Python-এ লিখে board-এর ফলের সঙ্গে মেলানো যাক। নিচের ব্লক ARM-এর সংজ্ঞা অনুযায়ী ADDS আর SUBS-এর ফল আর চারটি flag হিসাব করে।
# ARM-এর ADDS/SUBS: ৩২ বিটের ফল আর N Z C V (Python-এ simulation)
M = 0xFFFFFFFF
def adds(a, b):
r = (a + b) & M
c = int(a + b > M) # unsigned carry out
v = int((~(a ^ b) & (a ^ r)) >> 31 & 1) # একই চিহ্ন যোগে চিহ্ন বদল
return r, c, v
def subs(a, b):
r = (a - b) & M # a + NOT b + 1-এর সমান
c = int(a >= b) # ARM: C = 1 মানে borrow নেই
v = int(((a ^ b) & (a ^ r)) >> 31 & 1) # ভিন্ন চিহ্ন বিয়োগে চিহ্ন বদল
return r, c, v
cases = [("adds", 100, 50), ("adds", 0x7FFFFFFF, 1), ("adds", 0xFFFFFFFF, 1),
("subs", 1250, 1250), ("subs", 150, 1400), ("subs", 0x80000000, 1)]
for op, a, b in cases:
r, c, v = (adds if op == "adds" else subs)(a, b)
n, z = r >> 31, int(r == 0)
apsr = n << 31 | z << 30 | c << 29 | v << 28
print(f"{op} 0x{a:08X}, 0x{b:08X} -> 0x{r:08X} N={n} Z={z} C={c} V={v}"
f" APSR=0x{apsr:08X}")
r, c, v = subs(150, 1400)
print("150 - 1400 signed:", r - (1 << 32), "| ARM C =", c, "| x86 CF হতো", 1 - c)আসল আউটপুট (ব্রাউজারের Python):
adds 0x00000064, 0x00000032 -> 0x00000096 N=0 Z=0 C=0 V=0 APSR=0x00000000
adds 0x7FFFFFFF, 0x00000001 -> 0x80000000 N=1 Z=0 C=0 V=1 APSR=0x90000000
adds 0xFFFFFFFF, 0x00000001 -> 0x00000000 N=0 Z=1 C=1 V=0 APSR=0x60000000
subs 0x000004E2, 0x000004E2 -> 0x00000000 N=0 Z=1 C=1 V=0 APSR=0x60000000
subs 0x00000096, 0x00000578 -> 0xFFFFFB1E N=1 Z=0 C=0 V=0 APSR=0x80000000
subs 0x80000000, 0x00000001 -> 0x7FFFFFFF N=0 Z=0 C=1 V=1 APSR=0x30000000
150 - 1400 signed: -1250 | ARM C = 0 | x86 CF হতো 1
ছয়টি লাইনই board-এর সত্যিকারের mrs-এ পড়া APSR-এর সঙ্গে অক্ষরে অক্ষরে মেলে। V-এর দুটি সূত্র মনে রাখার মতো: যোগে দুটি operand-এর চিহ্ন এক অথচ ফলের চিহ্ন আলাদা হলে overflow; বিয়োগে দুটি operand-এর চিহ্ন আলাদা আর ফলের চিহ্ন প্রথমটির থেকে আলাদা হলে overflow. শেষ লাইন borrow-এর অর্থ দুই CPU-তে পাশাপাশি দেখায়। মনে রাখবেন, এটি Python-এ একটি simulation; আসল firmware C বা assembly-তে লেখা হয়, আর এখানে সত্যটা এসেছে board-এর run থেকে।
সাধারণ কোডে xPSR-এর অন্য দুই ভাগ দেখা যায় না, কিন্তু debugger বা HardFault-এর সময় পুরো ৩২ বিটের মান চোখে পড়ে। নিচের ব্লক এই পর্বের run-গুলো থেকে পাওয়া পাঁচটি xPSR মান তিন ভাগে খোলে।
# xPSR = APSR + IPSR + EPSR: তিনটি ভাগ একটি ৩২ বিটের word-এ
NAMES = {0: "Thread mode", 3: "HardFault", 11: "SVCall", 14: "PendSV",
15: "SysTick", 16: "IRQ0 (EXTI0)", 17: "IRQ1 (UART)"}
def decode(x):
flags = "".join(f if x >> b & 1 else "-" for f, b in
[("N", 31), ("Z", 30), ("C", 29), ("V", 28), ("Q", 27)])
t = x >> 24 & 1 # EPSR.T: Thumb state
it = (x >> 25 & 3) | (x >> 10 & 0x3F) << 2 # EPSR-এর IT/ICI বিট
exc = x & 0x1FF # IPSR: exception নম্বর
return f"APSR {flags} T={t} IT={it} IPSR={exc} {NAMES.get(exc, '?')}"
runs = [("reset-এর পরে", 0x01000000),
("net_price-এ subs-এর পরে", 0x21000000),
("SysTick handler-এর ভেতরে", 0x0100000F),
("handler-এ movs r1,#0-এর পরে", 0x4100000F),
("mrs rX, apsr (adds 0x7FFFFFFF+1)", 0x90000000)]
for label, x in runs:
print(f"0x{x:08X} {decode(x)} <- {label}")আসল আউটপুট (ব্রাউজারের Python):
0x01000000 APSR ----- T=1 IT=0 IPSR=0 Thread mode <- reset-এর পরে
0x21000000 APSR --C-- T=1 IT=0 IPSR=0 Thread mode <- net_price-এ subs-এর পরে
0x0100000F APSR ----- T=1 IT=0 IPSR=15 SysTick <- SysTick handler-এর ভেতরে
0x4100000F APSR -Z--- T=1 IT=0 IPSR=15 SysTick <- handler-এ movs r1,#0-এর পরে
0x90000000 APSR N--V- T=0 IT=0 IPSR=0 Thread mode <- mrs rX, apsr (adds 0x7FFFFFFF+1)
প্রথম চারটি মান board-এর CPU-র পুরো xPSR, যা অংশ ৪ আর ৬-এর trace-এ সত্যিই দেখা গেছে; সবগুলোতে T = 1, কারণ Cortex-M শুধু Thumb চালায়। শেষটি MRS ..., APSR দিয়ে পড়া: ARMv7-M-এ এভাবে পড়লে শুধু APSR-এর বিট আসে, বাকিগুলো 0 হিসেবে পড়ে, তাই সেখানে T = 0 দেখাচ্ছে। এটি CPU-র অবস্থা নয়, পড়ার নিয়মের ফল। তৃতীয় আর চতুর্থ লাইনে IPSR = 15: CPU তখন SysTick-এর handler চালাচ্ছে।
৪ · Thumb-2 আর load/store — বাজারঘরের একটি function, নির্দেশ ধরে ধরে
Cortex-M শুধু একটি নির্দেশ-সংকলন চালায়: Thumb-2. এতে বেশিরভাগ সাধারণ নির্দেশ ১৬ বিটের (২ byte), আর যেগুলো ১৬ বিটে আঁটে না (বড় constant, তিন register, ৬৪ বিটের গুণ) সেগুলো ৩২ বিটের। দুই দৈর্ঘ্য একই program-এ পাশাপাশি চলে, কোনো mode বদল ছাড়া। প্রথম halfword দেখেই CPU বোঝে নির্দেশটি দুই না চার byte: উপরের পাঁচ বিট 11101, 11110 বা 11111 হলে ৩২ বিটের। এর লাভ code density: microcontroller-এর flash ছোট, তাই একই কাজ কম byte-এ।
দ্বিতীয় মূল নিয়ম load/store architecture: হিসাবের নির্দেশ (ADD, MUL, CMP) শুধু register নিয়ে কাজ করে। মেমরি ছোঁয় কেবল LDR (load) আর STR (store) আর তাদের আত্মীয়রা। 8086-এর add [bx], ax-এর মতো “মেমরিতে সরাসরি যোগ” এখানে নেই; সেই কাজ তিনটি নির্দেশ: LDR, ADD, STR. এটি RISC নকশার বৈশিষ্ট্য, আর এর তত্ত্ব আছে Computer Architecture পর্ব ২৫-এ। Peripheral register-ও মেমরির ঠিকানায় বসে (memory-mapped I/O), তাই LED জ্বালানোও শেষ পর্যন্ত একটি STR.
এবার বাস্তব উদাহরণ। বাজারঘরের smart scale-এ মোট ওজন থেকে tare বাদ দিয়ে দাম বের করার একটি ছোট function, reference lab-এর scale.c-এর price_paisa()-এর নিয়মে (65.50 টাকা/kg = 6550 পয়সা/kg, অর্ধেক হলে ওপরে):
/* smart scale: price of (gross - tare) in paisa, 65.50 Tk/kg */
__attribute__((noinline)) int32_t net_price(int32_t gross_g, int32_t tare_g)
{
int32_t net = gross_g - tare_g;
if (net <= 0)
return 0;
return (net * 6550 + 500) / 1000;
}সত্যিকারের Clang 22.1.8 output (clang -S --target=thumbv7m-none-eabi -mcpu=cortex-m3 -O2 -fno-sanitize=undefined, zig cache নিজের lab-এ), ডানে board থেকে পড়া আসল machine code-এর halfword:
net_price: @ ঠিকানা machine code
subs r0, r0, r1 @ 0x08000060 1A40
movw r1, #6550 @ 0x08000062 F641 1196
muls r1, r0, r1 @ 0x08000066 4341
movw r2, #19923 @ 0x08000068 F644 52D3
add.w r1, r1, #500 @ 0x0800006C F501 71FA
movt r2, #4194 @ 0x08000070 F2C1 0262
cmp r0, #0 @ 0x08000074 2800
mov.w r0, #0 @ 0x08000076 F04F 0000
umull r1, r2, r1, r2 @ 0x0800007A FBA1 1202
it gt @ 0x0800007E BFC8
lsrgt r0, r2, #6 @ 0x08000080 0990
bx lr @ 0x08000082 4770
বারোটি নির্দেশ, মোট ৩৬ byte: ছয়টি ১৬ বিটের (১২ byte) আর ছয়টি ৩২ বিটের (২৪ byte). কয়েকটি জিনিস চোখে পড়ার মতো। প্রথমত, কোনো PUSH নেই, stack ছোঁয়া হয়নি: argument এসেছে R0 আর R1-এ, ফল যাবে R0-এ, আর leaf function বলে LR-এ ফেরার ঠিকানা নিরাপদ। দ্বিতীয়ত, ৩২ বিটের constant 0x10624DD3 একটি নির্দেশে আঁটে না, তাই movw নিচের ১৬ বিট আর movt ওপরের ১৬ বিট বসায়। তৃতীয়ত, if-এর জন্য কোনো লাফ নেই: IT block (it gt) পরের নির্দেশটিকে শর্তযুক্ত করে, “শুধু greater than হলে চলবে”। লাফ না থাকলে pipeline খালি হয় না।
চতুর্থ আর সবচেয়ে মজার: C-তে / 1000 লেখা, অথচ কোডে কোনো ভাগের নির্দেশ নেই। Cortex-M3-এ SDIV আর UDIV আছে (একটি hardware divider), তবু Clang বেছেছে গুণ: 1000 দিয়ে ভাগ = 0x10624DD3 দিয়ে গুণ করে ৩৮ বিট ডানে সরানো। UMULL ৬৪ বিটের গুণফলের উঁচু ৩২ বিট R2-এ রাখে (মানে ৩২ বিট সরানো হয়ে গেল), তারপর lsrgt r0, r2, #6 আরও ৬ বিট। এ হলো strength reduction-এর একটি রূপ: Cortex-M3 TRM অনুযায়ী ভাগে ইনপুটভেদে কয়েক থেকে বারোটির মতো cycle লাগে, আর গুণ সাধারণত তার চেয়ে কম।
এবার এই function board-এ সত্যিই চলার সময় register কীভাবে বদলায়। প্রথমে board-এর নিজের --trace (প্রথম N নির্দেশের ঠিকানা আর symbol):
$ python -B board.py run build/cm3.elf --trace 260
...
[ 0.0293 ms] trace PC=0x08000116 main+0x42
[ 0.0294 ms] trace PC=0x08000060 net_price+0x0
[ 0.0295 ms] trace PC=0x08000062 net_price+0x2
[ 0.0296 ms] trace PC=0x08000066 net_price+0x6
...
[ 0.0307 ms] trace PC=0x08000082 net_price+0x22
[ 0.0309 ms] trace PC=0x0800011A main+0x46
main+0x42-এ ৩২ বিটের bl net_price, আর ফিরে আসা main+0x46-এ, অর্থাৎ ৪ byte পরে। Board-এর trace শুধু ঠিকানা দেখায়, register দেখায় না; তাই আমার lab-এ একটি ছোট script, regtrace.py, board.py-র Board class-এ একটি Unicorn hook যোগ করে প্রতিটি নির্দেশের আগে R0–R3 আর xPSR ছাপে (reference lab-এর কোনো ফাইল বদলানো হয়নি)। সেই সত্যিকারের run থেকে নেওয়া মান নিচের stepper-এ, প্রতিটি নির্দেশ চলার পরে:
060subs r0,r0,r1062movw r1,#6550066muls r1,r0,r1068movw r2,#1992306Cadd.w r1,r1,#500070movt r2,#4194074cmp r0,#0076mov.w r0,#007Aumull r1,r2,r1,r207Eit gt080lsrgt r0,r2,#6082bx lr
| R0 | |
| R1 | |
| R2 | |
| N Z C V | |
| দৈর্ঘ্য | |
| পরের PC |
subs r0,r0,r1. ঢোকার সময় R0 = 0x578 (1400 g), R1 = 0x96 (150 g), xPSR = 0x81000000. বিয়োগে R0 = 0x4E2 = 1250 g. Borrow নেই, তাই C = 1; xPSR = 0x21000000. R2-তে আগের কাজের পুরোনো মান 0x40004400 (UART-এর ঠিকানা) পড়ে আছে, কোনো অর্থ নেই।movw r1,#6550. দর 6550 = 0x1996 R1-এ। ৩২ বিটের নির্দেশ, কারণ ১৬ বিটেরmovs-এ সর্বোচ্চ 255 আঁটে। R1-এর tare আর লাগবে না, তাই compiler register-টি আবার ব্যবহার করল।muls r1,r0,r1. 1250 × 6550 = 8187500 = 0x7CEE6C. ১৬ বিটেরMULSN আর Z বদলায় (দুটিই 0), C আগের মতোই থাকে।movw r2,#19923. Magic constant-এর নিচের ১৬ বিট: 19923 = 0x4DD3. Compiler নির্দেশগুলো মিশিয়ে সাজিয়েছে, যাতে একটির ফল পরেরটির জন্য অপেক্ষা না করায়।add.w r1,r1,#500. অর্ধেক পয়সা ওপরে নিতে +500: 8187500 + 500 = 8188000 = 0x7CF060..wমানে “wide”, ৩২ বিটের রূপ; এখানে S নেই, তাই flag বদলায়নি।movt r2,#4194. ওপরের ১৬ বিট 4194 = 0x1062 বসল, নিচেরটা অক্ষত: R2 = 0x10624DD3 = 274877907 ≈ 238 ÷ 1000.cmp r0,#0.if (net <= 0)-এর পরীক্ষা: 1250 − 0, ফল কোথাও রাখা হয় না, শুধু flag: N = 0, Z = 0, C = 1, V = 0. এই flag-ই পরে “gt” ঠিক করবে।mov.w r0,#0. আগেভাগে ফেরত মান 0 ধরে রাখা হলো (net ≤ 0 হলে এটিই ফল)। S ছাড়াmov.wflag ছোঁয় না, তাইcmp-এর flag অক্ষত থাকে।umull r1,r2,r1,r2. ৩২ × ৩২ = ৬৪ বিট: 8188000 × 0x10624DD3. নিচের অর্ধেক R1 = 0x0006FF20, উঁচু অর্ধেক R2 = 0x0007FF00 = 524032. উঁচু অর্ধেক নেওয়া মানে ৩২ বিট ডানে সরানো।it gt. পরের একটি নির্দেশ চলবে শুধু “greater than” হলে: Z = 0 আর N = V. Flag 0 0 1 0, তাই শর্ত সত্য। এই নির্দেশ নিজে কোনো register বদলায় না।lsrgt r0,r2,#6. শর্ত সত্য, তাই চলল: 524032 ÷ 64 = 8188 = 0x1FFC. মোট সরানো ৩২ + ৬ = ৩৮ বিট। 8188 পয়সা = 81.88 টাকা, README-র মান হুবহু।bx lr. LR = 0x0800011B: বিট ০ = 1 মানে Thumb, ঠিকানা 0x0800011A. ফল R0-এ, PC গেলmain+0x46-এ। Board-এ এই বারোটি নির্দেশ ১২ cycle, কারণ সেখানে ১টি নির্দেশ = ১ cycle (Spec decision 17).
Magic number-টি কি সত্যিই সব ওজনে ঠিক ফল দেয়? Compiler-এর ওপর অন্ধ বিশ্বাস না রেখে যাচাই করা যায়। নিচের ব্লক 1 থেকে 5000 g পর্যন্ত প্রতিটি ওজনে আর কয়েকটি প্রান্তের মানে দুই পদ্ধতির ফল মেলায়।
# Clang-এর কৌশল: x / 1000 == (x * 0x10624DD3) >> 38 ? (UMULL + LSR #6)
MAGIC, SHIFT = 0x10624DD3, 38 # movw/movt আর lsr #6 (32 + 6 = 38)
print("2^38 / 1000 =", 2**38 / 1000, "-> ceil =", -(-2**38 // 1000),
"=", hex(-(-2**38 // 1000)))
x = 1250 * 6550 + 500
hi = (x * MAGIC) >> 32 # UMULL-এর উঁচু word (R2)
print(f"x = {x} = 0x{x:X}; umull-এর উঁচু word = 0x{hi:X} = {hi}; >> 6 = {hi >> 6}")
bad = [n for n in range(1, 5001) # scale-এর পুরো ক্ষমতা: 5000 g
if ((n * 6550 + 500) * MAGIC) >> SHIFT != (n * 6550 + 500) // 1000]
print("1..5000 g-এ অমিল:", len(bad))
edge = [0, 999, 1000, 2**31 - 1, 2**32 - 1, 4294966999, 4294967000]
print("প্রান্তের x-এ অমিল:", [e for e in edge if (e * MAGIC) >> SHIFT != e // 1000])
print("int32 না উপচে সর্বোচ্চ net:", (2**31 - 1 - 500) // 6550, "g")আসল আউটপুট (ব্রাউজারের Python):
2^38 / 1000 = 274877906.944 -> ceil = 274877907 = 0x10624dd3
x = 8188000 = 0x7CF060; umull-এর উঁচু word = 0x7FF00 = 524032; >> 6 = 8188
1..5000 g-এ অমিল: 0
প্রান্তের x-এ অমিল: []
int32 না উপচে সর্বোচ্চ net: 327860 g
Magic constant হলো 238 ÷ 1000-কে ওপরের দিকে গোল করা, আর stepper-এর R2 = 0x7FF00 আর ফল 8188 এখানে হুবহু ফিরে এসেছে। Scale-এর পুরো সীমায় একটিও অমিল নেই, আর ৩২ বিটের একেবারে কিনারার মানেও না। শেষ লাইনটি একটি সতর্কবার্তা: net * 6550 হয় int32_t-এ, তাই net 327860 g-এর বেশি হলে C-তে signed overflow, যা undefined behavior. Scale-এর ক্ষমতা 5000 g, তাই নিরাপদ; কিন্তু একই function গুদামের ২ টনের দাঁড়িপাল্লায় বসালে ভুল দাম দেবে।
৫ · Pipeline — fetch, decode, execute একসঙ্গে
8086-এর ৬ byte-এর queue মনে আছে (পর্ব ১৪)? Cortex-M3 একই ধারণা আরও গুছিয়ে করে: Cortex-M3 TRM-এ একটি তিন ধাপের pipeline-এর কথা আছে: Fetch (flash থেকে নির্দেশ আনা), Decode (বোঝা আর register পড়া), Execute (ALU, গুণ-ভাগ, load/store, লেখা)। এক ঘড়ির টিকে তিনটি আলাদা নির্দেশ তিন ধাপে থাকে, তাই অনেক সাধারণ নির্দেশ গড়ে এক cycle-এ শেষ হয়। Fetch একবারে ৩২ বিট আনে, অর্থাৎ দুটি ১৬ বিটের নির্দেশ একসঙ্গে, যা Thumb-এর ঘনত্বের আরেকটি লাভ। Pipeline-এর সাধারণ তত্ত্ব আর hazard Computer Architecture পর্ব ৩৫-এ।
| ঘড়ির টিক | Fetch | Decode | Execute |
|---|---|---|---|
| ১ | subs | — | — |
| ২ | movw r1 | subs | — |
| ৩ | muls | movw r1 | subs |
| ৪ | movw r2 | muls | movw r1 |
এটি একটি আদর্শ ছবি, আসল সময় নয়। বাস্তবে flash-এর wait state, লাফের পরে pipeline আবার ভরা (TRM-এ লাফের লক্ষ্য আগে থেকে আনার একটি ব্যবস্থার কথা আছে, তবু taken branch সাধারণত কয়েক cycle বেশি নেয়), আর গুণ-ভাগ বা load-এর বাড়তি cycle মিলিয়ে সময় বদলায়। এই কারণেই it gt দিয়ে লাফ এড়ানো লাভজনক। আর একটি সাবধানতা: R15 পড়লে যে মান আসে তা এখনকার নির্দেশের ঠিকানা + 4, pipeline-এর ইতিহাস থেকে আসা একটি নিয়ম।
সাবধান — board-এর সময় আসল সময় নয়: কোর্সের virtual board-এ প্রতিটি নির্দেশ ঠিক ১ cycle, exception-এ ঢোকা-বেরোনো ০ cycle (Spec decision 17). তাই trace-এর 0.0294 ms থেকে 0.0307 ms মানে “১২টি নির্দেশ”, “আসল M3-এ এত সময়” নয়। UMULL বা SDIV-এর আসল cycle সংখ্যা, বা interrupt latency (আসল M3-এ প্রায় ১২ cycle বলে ধরা হয়) জানতে হবে TRM আর chip-এর datasheet থেকে।
৬ · Thread আর Handler mode, privileged আর unprivileged
Cortex-M-এর CPU সবসময় দুটি mode-এর একটিতে থাকে। Thread mode-এ চলে সাধারণ program: main() আর তার ডাকা function. কোনো exception (interrupt, fault, SysTick) এলে CPU যায় Handler mode-এ, handler শেষ হলে ফিরে আসে। কোন mode-এ আছে, তা IPSR বলে: 0 মানে Thread, অন্য যেকোনো সংখ্যা মানে সেই নম্বরের exception-এর handler. Reset-এর পরে CPU Thread mode-এ, privileged অবস্থায় আর MSP নিয়ে শুরু করে।
এর পাশে দ্বিতীয় একটি মাত্রা: অধিকার বা privilege level. Privileged কোড সব কিছু ছুঁতে পারে: CPSID দিয়ে interrupt বন্ধ, NVIC আর SysTick-এর register, CONTROL. Unprivileged কোডের এসব নিষেধ; এর উদ্দেশ্য হলো RTOS-এর একটি task ভুল করলেও পুরো system যেন না ভাঙে (MPU থাকলে মেমরিও আটকানো যায়)। Handler mode সবসময় privileged. Thread mode-এর অধিকার ঠিক করে CONTROL-এর বিট ০, nPRIV. আর CONTROL-এর বিট ১, SPSEL, ঠিক করে Thread mode কোন stack pointer ব্যবহার করবে: 0 হলে MSP (Main SP), 1 হলে PSP (Process SP). Handler mode সবসময় MSP ব্যবহার করে।
| অবস্থা | অধিকার | Stack pointer | কে ব্যবহার করে |
|---|---|---|---|
| Thread, CONTROL = 0 | privileged | MSP | সরল bare-metal firmware (এই কোর্সের board-এর সব example) |
| Thread, nPRIV = 1 | unprivileged | MSP বা PSP | সুরক্ষিত RTOS-এর task |
| Thread, SPSEL = 1 | যেকোনো | PSP | RTOS-এর task, প্রত্যেকের নিজের stack |
| Handler | সবসময় privileged | সবসময় MSP | ISR, fault handler, RTOS kernel |
দুটি stack pointer কেন? RTOS-এ প্রতিটি task-এর নিজের stack থাকে, আর task বদলাতে শুধু PSP বদলালেই চলে। অথচ সব interrupt একটি সাধারণ stack-এ (MSP) চলে, তাই প্রতিটি task-এর stack-এ interrupt-এর জন্য বাড়তি জায়গা রাখতে হয় না। RTOS-এর এই ব্যবহার মডিউল ৯-এ। একটি সীমা আগেই জেনে রাখুন: কোর্সের board PSP, SVC আর PendSV মডেল করে না (Spec decision 19), তাই এই পর্বের সব run MSP-তে।
এবার mode বদল নিজের চোখে। cm3.c-র শেষ অংশ SysTick-কে 1 ms-এ একবার interrupt দিতে সাজায় (LOAD = 7999, Spec decision 22), তারপর WFI-তে ঘুমায়। Handler-এর ভেতরে mov r0, lr, mrs r0, ipsr, mrs r0, msp আর mrs r0, control দিয়ে চারটি মান ধরে রাখা হয়, আর main পরে ছাপে:
[ 0.7060 ms] UART: thread: IPSR=0 CONTROL=0 MSP=0x20005000
[ 1.7828 ms] UART: handler: IPSR=15 CONTROL=0 MSP=0x20004FE0 LR=0xFFFFFFF9
[ 1.8208 ms] UART: back: IPSR=0 MSP=0x20005000
Handler-এ SP ঠিক ৩২ byte (0x20 = আট word) কম, আর LR-এ কোনো ফেরার ঠিকানা নেই, আছে 0xFFFFFFF9. এই দুটি জিনিস বুঝতে regtrace.py-এর আরও খুঁটিনাটি নিচে। Handler-এর প্রথম নির্দেশে SP-তে পাওয়া আট word ছিল 20000018 00000000 40004400 C0000000 CCCCCCCD 080001C7 080001E2 01000000.
| mode · IPSR | |
| SP (MSP) | |
| LR | |
| PC | |
| R0 · R1 | |
| stack-এ |
- Thread mode, ঘুমের মুখে।
main0x080001E0-এWFI-তে। R0 = 0x20000018, অর্থাৎh_done-এর ঠিকানা; R1 = 0, কারণh_doneএখনো 0. SP = 0x20005000, SRAM-এর একেবারে শেষ (_estack). - Hardware-এর stacking. SysTick-এর counter 0-তে পৌঁছাল। কোনো নির্দেশ ছাড়াই CPU আট word ঠেলে দেয়: R0, R1, R2, R3, R12, LR, ফেরার PC = 0x080001E2 (
WFI-এর পরের নির্দেশ) আর xPSR = 0x01000000. SP 32 byte নেমে 0x20004FE0. R12-এর 0xCCCCCCCD আগের কাজের অবশিষ্ট। - Handler mode-এ প্রবেশ। IPSR = 15, xPSR = 0x0100000F. LR-এ বসল EXC_RETURN 0xFFFFFFF9: “Thread mode-এ, MSP নিয়ে ফিরবে”। PC এল vector table-এর ১৫ নম্বর ঘর থেকে: 0x08000085, বিট ০ বাদ দিয়ে 0x08000084.
- Handler-এর কাজ। চারটি মান সংরক্ষণ, SysTick বন্ধ,
h_done = 1: শেষে R1 = 1. Handler সাধারণ C function, কারণ hardware আগেই R0–R3, R12, LR বাঁচিয়ে রেখেছে, যেগুলো C-র নিয়মে নষ্ট হতে পারে। এবারbx lr, যেখানে LR = 0xFFFFFFF9. - Unstacking আর ফেরা। 0xFFFFFFF9-এ লাফ মানে আসলে ফেরার সংকেত। CPU আট word তুলে নেয়: R1 আবার 0, LR = 0x080001C7, PC = 0x080001E2, xPSR = 0x01000000, SP = 0x20005000. Thread mode-এর কোড টেরই পায় না, মাঝে কিছু ঘটেছিল।
এখানে board-এর মডেলের সীমা স্পষ্ট করে বলা দরকার। Stacking আর unstacking Unicorn নিজে করে না; board.py-র Python কোড একই স্থাপত্যের নিয়মে করে: আট word-এর frame, 8 byte alignment-এর জন্য xPSR-এর বিট ৯, EXC_RETURN 0xFFFFFFF9 বা nested হলে 0xFFFFFFF1 (Spec decision 19). Interrupt কখন ঢুকবে, তা পরীক্ষা হয় নির্দিষ্ট “boundary”-তে (Spec decision 20). Priority, nesting, tail-chaining আর frame-এর পুরো গল্প পরের পর্বে, পর্ব ৩০-এ (Cortex-M-এর exception আর NVIC).
Privilege নিজে পরীক্ষা করা
আমার lab-এর priv.c privileged অবস্থায় CONTROL-এ 1 লিখে (nPRIV = 1) নিজেকে unprivileged বানায়, তারপর দুটি নিষিদ্ধ কাজ চেষ্টা করে: cpsid i দিয়ে interrupt বন্ধ, আর CONTROL-এ 0 লিখে আবার privileged হওয়া। সত্যিকারের run:
[ 0.0285 ms] UART: privileged: CONTROL=0
[ 0.0551 ms] UART: after nPRIV=1: CONTROL=1
[ 0.0890 ms] UART: cpsid i as unprivileged: PRIMASK=0
[ 0.1149 ms] UART: try nPRIV=0: CONTROL=1
দুটি নিষিদ্ধ কাজই চুপচাপ উপেক্ষিত হলো: PRIMASK 0-ই রইল (interrupt বন্ধ হয়নি), CONTROL 1-ই রইল। ARMv7-M-এর নিয়মও এটাই: unprivileged অবস্থায় এই লেখাগুলো fault দেয় না, শুধু কাজ করে না। এই run-এ Unicorn-এর ARMv7-M CPU নিয়মটি মেনেছে; তবে reference lab-এর Spec decision-এ privilege আলাদা করে মডেল বা পরীক্ষা করা হয়েছে বলে লেখা নেই, তাই এর বাইরের আচরণ আসল chip-এ যাচাই করবেন। আর এই প্রশ্নটি থেকে যায়: unprivileged কোড ফিরবে কীভাবে? উত্তর: একটি exception দিয়ে, সাধারণত SVC নির্দেশ, যার handler privileged বলে CONTROL বদলাতে পারে। RTOS-এর system call ঠিক এভাবে কাজ করে। Board SVC মডেল করে না (Spec decision 19), তাই এটি এখানে চালানো হয়নি।
৭ · Memory model আর bit-banding
Cortex-M-এর ঠিকানার জায়গা একটি সমতল 4 GB, 0x00000000 থেকে 0xFFFFFFFF; 8086-এর মতো segment নেই, যেকোনো ৩২ বিটের register সরাসরি যেকোনো ঠিকানা ধরে। ARMv7-M এই 4 GB-কে বড় বড় অঞ্চলে ভাগ করে দিয়েছে: নিচে code (flash), 0x20000000 থেকে SRAM, 0x40000000 থেকে peripheral, আর 0xE0000000 থেকে core-এর নিজের register (NVIC, SysTick, SCB). কোর্সের board-এ flash 0x08000000 থেকে 128 KiB আর SRAM 0x20000000 থেকে 20 KiB (Spec decision 18). পুরো মানচিত্র আর linker script পর্ব ৩১-এ (Memory map আর linker script). Data সাজানো little-endian-এ: 1250 = 0x000004E2 মেমরিতে E2 04 00 00.
এবার একটি চেনা সমস্যা। Smart scale-এর একটি ৩২ বিটের flags_word-এর বিট ৩ মানে “tare চাওয়া হয়েছে”। Main loop লেখে flags_word |= 1u << 3, আর একটি ISR একই word-এর অন্য বিট বদলায়। C-র এই এক লাইন আসলে তিনটি নির্দেশ: LDR, ORR, STR, একটি read-modify-write. LDR আর STR-এর মাঝে interrupt এসে অন্য বিট বদলালে, STR সেই বদল মুছে দেবে। Load/store architecture-এর এটি একটি স্বাভাবিক ফাঁদ।
Cortex-M3 আর M4-এর একটি সমাধান bit-banding. SRAM-এর প্রথম 1 MB (0x20000000–0x200FFFFF) আর peripheral-এর প্রথম 1 MB (0x40000000–0x400FFFFF)-এর প্রতিটি বিটের জন্য একটি আলাদা ৩২ বিটের “alias” ঠিকানা আছে, যথাক্রমে 0x22000000 আর 0x42000000 থেকে। Alias-এ 1 লিখলে hardware নিজেই সেই একটি বিট 1 করে, অন্য বিট না ছুঁয়ে, আর bus-এর দিক থেকে কাজটি অবিভাজ্য। Cortex-M3 TRM-এর সূত্র:
bit_word_addr = bit_band_base + byte_offset × 32 + bit_number × 4
# Cortex-M3/M4-এর bit-band alias ঠিকানা (TRM-এর সূত্র)
def alias(addr):
for base, abase in ((0x20000000, 0x22000000), (0x40000000, 0x42000000)):
if base <= addr < base + 0x100000: # 1 MB bit-band অঞ্চল
return abase, addr - base
raise ValueError(f"0x{addr:08X} bit-band অঞ্চলে নেই")
def bit_word(addr, bit):
abase, off = alias(addr)
return abase + off * 32 + bit * 4
for name, addr, bit in [("flags_word বিট 3", 0x20000000, 3),
("SRAM 0x20000300 বিট 7", 0x20000300, 7),
("GPIOA ODR (0x4001080C) বিট 5 = PA5 LED", 0x4001080C, 5)]:
print(f"{name:40} -> 0x{bit_word(addr, bit):08X}")
print("SRAM-এর 1 MB -> alias", hex(0x100000 * 32), "byte = 32 MB")
try:
bit_word(0x08000000, 0)
except ValueError as e:
print("flash:", e)আসল আউটপুট (ব্রাউজারের Python):
flags_word বিট 3 -> 0x2200000C
SRAM 0x20000300 বিট 7 -> 0x2200601C
GPIOA ODR (0x4001080C) বিট 5 = PA5 LED -> 0x42210194
SRAM-এর 1 MB -> alias 0x2000000 byte = 32 MB
flash: 0x08000000 bit-band অঞ্চলে নেই
প্রতিটি byte-এ আটটি বিট, প্রতিটি বিটের জন্য ৪ byte-এর একটি word, তাই alias অঞ্চল মূল অঞ্চলের ৩২ গুণ: 1 MB থেকে 32 MB. GPIOA-র ঠিকানা কোর্সের board-এর bazarghar.h থেকে নেওয়া। Flash bit-band অঞ্চলে পড়ে না, আর তার দরকারও নেই, কারণ সেখানে সাধারণ store দিয়ে লেখাই যায় না।
এবার সতর্কতার দিক। আমার lab-এর priv.c-র শেষ অংশ flags_word-এর বিট ৩-এর alias, 0x2200000C, ঠিকানায় 1 লেখে। আসল Cortex-M3-এ এতে flags_word = 8 হতো। Virtual board-এ সত্যিকারের ফল:
[ 0.1855 ms] UART: flags_word at 0x536870912, alias=570425356
[ 0.1861 ms] HardFault: Invalid memory write (UC_ERR_WRITE_UNMAPPED) at PC=0x08000150 main+0xD4
[ 0.1998 ms] UART: HardFault taken
[ 0.2006 ms] exit(3) after 1605 cycles
(UART-এ ঠিকানা দশমিকে ছাপা: 536870912 = 0x20000000, 570425356 = 0x2200000C.) Board শুধু 0x20000000 থেকে 20 KiB SRAM map করে, alias অঞ্চল নয়, তাই লেখাটি HardFault দিল। অর্থাৎ এই virtual board bit-banding মডেল করে না; README-র Spec decision-এ এটি আলাদা করে লেখা নেই, এই run-এ দেখা গেছে। আর আসল chip-এও সাবধান: bit-banding Cortex-M3/M4-এ chip নির্মাতার বেছে নেওয়ার বিষয়, আর Cortex-M0/M0+, M7 আর ARMv8-M-এর core-গুলোতে (যেমন M33) সাধারণত থাকে না। তাই নিজের chip-এর reference manual না দেখে alias ব্যবহার করবেন না। বহনযোগ্য বিকল্প: GPIO-র BSRR-এর মতো “শুধু-set/শুধু-reset” register (পর্ব ৩৫-এ), অল্প সময় interrupt বন্ধ রাখা (পর্ব ৪৩-এ), বা LDREX/STREX-এর atomic operation.
আরও গভীরে: Cortex-M3-এ bus-এর দিক থেকে bit-band লেখা আসলে একটি read-modify-write, যা bus matrix নিজে “locked” ক্রমে করে, তাই মাঝখানে অন্য master ঢুকতে পারে না (Cortex-M3 TRM-এর bit-banding অংশ)। Core-এর ভেতরে আরও দুটি bus interface আছে, ICode আর DCode, code অঞ্চলের নির্দেশ আর data একসঙ্গে আনতে, আর একটি System bus বাকি অঞ্চলের জন্য; এভাবে Cortex-M3 ভেতরে Harvard ধাঁচে কাজ করে, অথচ programmer একটিই সমতল ঠিকানার জায়গা দেখেন। ARMv8-M-এ bit-banding বাদ পড়ার একটি কারণ হিসেবে প্রায়ই বলা হয়, cache আর বহু-master-এর জটিল system-এ এটি ঠিকঠাক রাখা কঠিন, আর exclusive access নির্দেশ সাধারণ সমাধান হিসেবে যথেষ্ট; এটি ARM-এর আনুষ্ঠানিক কারণ কি না, নিশ্চিত নই।
৮ · 8086 বনাম Cortex-M3 — পরীক্ষার ধাঁচে তুলনা
বিশ্ববিদ্যালয়, চাকরি আর ইন্টারভিউর পরীক্ষায় “8086 আর ARM Cortex-M-এর পার্থক্য লিখুন” ধাঁচের প্রশ্ন প্রায়ই আসে। মুখস্থ তালিকার চেয়ে প্রতিটি পার্থক্যের কারণ বলতে পারলে উত্তর অনেক শক্ত হয়:
| দিক | 8086 (পর্ব ১৪) | Cortex-M3 | কেন আলাদা |
|---|---|---|---|
| ISA-র ধরন | CISC, নির্দেশ ১–৬ byte | RISC, Thumb-2: ২ বা ৪ byte | সহজ decode, ঘন কোড |
| ঠিকানা | segment × 10H + offset, 1 MB | সমতল ৩২ বিট, 4 GB | ৩২ বিটের register নিজেই যথেষ্ট |
| মেমরিতে হিসাব | add [bx],ax চলে | শুধু LDR/STR | load/store: সরল pipeline |
| ফেরার ঠিকানা | CALL stack-এ রাখে | BL LR-এ রাখে | leaf function-এ মেমরি লাগে না |
| Flag বদল | প্রায় সব হিসাবের নির্দেশে | শুধু S-ওয়ালা নির্দেশ আর CMP | flag ধরে রেখে নির্দেশ সাজানো যায় |
| বিয়োগের carry | CF = 1 মানে borrow | C = 1 মানে borrow নেই | ARM বিয়োগ = a + NOT b + 1 |
| Interrupt-এ | FLAGS, CS, IP push (পর্ব ২০) | আট register hardware-এ push | ISR সাধারণ C function হতে পারে |
| Prefetch | ৬ byte-এর queue | ৩ ধাপের pipeline | দুটিই fetch আর execute একসঙ্গে |
| Mode | শুধু real mode, সুরক্ষা নেই | Thread/Handler, privileged/unprivileged | RTOS আর নিরাপদ firmware |
বাজারঘরের দাম হিসাবের তুলনাটিও শিক্ষণীয়। পর্ব ১৪-এ 8086 একই 1250 × 6550 + 500, তারপর ÷ 1000 করেছিল MUL-এ DX:AX জোড়া আর DIV দিয়ে। Cortex-M3-এ ৩২ বিটের একটি register-এই গুণফল আঁটে, আর compiler ভাগটিকে গুণ আর shift-এ বদলে দিয়েছে। দুটি chip একই উত্তর দিয়েছে, 8188 পয়সা, কিন্তু পথ একেবারে আলাদা।
পরীক্ষা ও ইন্টারভিউতে: “Cortex-M-এ R13, R14, R15 কী?” → SP, LR, PC. “MSP আর PSP-এর পার্থক্য” → Handler আর reset-এর পরে MSP; RTOS-এর task সাধারণত PSP (CONTROL.SPSEL = 1). “Exception-এ hardware কোন register stack করে?” → R0–R3, R12, LR, PC, xPSR, আট word. “LR = 0xFFFFFFF9 মানে?” → EXC_RETURN: Thread mode-এ MSP নিয়ে ফেরা। “0x20000300-এর বিট 7-এর bit-band alias?” → 0x22000000 + 0x300 × 32 + 7 × 4 = 0x2200601C.
৯ · AI-এর যুগে Cortex-M-এর গঠন যাচাই
Cortex-M নিয়ে AI assistant সাধারণত ভালো সারাংশ দেয়, কিন্তু খুঁটিনাটিতে ভুল করে, আর সেই খুঁটিনাটিই firmware ভাঙে। কয়েকটি পরিচিত ভুল আর ধরার উপায়:
| AI প্রায়ই যা করে | কীভাবে ধরবেন |
|---|---|
| ARM-এর বিয়োগে C = 1-কে “borrow হয়েছে” বলে, 8086-এর মতো | Board-এ subs চালিয়ে mrs apsr পড়া: 150 − 1400-এ C = 0 |
Cortex-M-এ ARM state, MOV PC, LR-এর পুরোনো ধাঁচ বা Cortex-A-র mode (IRQ, FIQ, SVC mode) মিশিয়ে ফেলে | ARMv7-M-এ শুধু Thread আর Handler mode, শুধু Thumb; ARMv7-M Architecture Reference Manual দেখা |
| “Exception-এ সব ১৬টি register stack হয়” বা ভুল ক্রম বলে | Board-এর trace-এ SP ঠিক 32 byte নেমেছে কি না, আর frame-এর আটটি word মেলানো |
| নির্দিষ্ট chip-এর জন্য register-এর ঠিকানা বানিয়ে বলে, বা সব M-core-এ bit-banding আছে বলে | Chip-এর reference manual; এই কোর্সে bazarghar.h আর README-র memory map |
| Cycle সংখ্যা নিশ্চিতভাবে বলে (“UMULL সবসময় ১ cycle”) | Cortex-M3 TRM-এর instruction timing; board-এর ১ নির্দেশ = ১ cycle আসল সময় নয় (Spec decision 17) |
Interrupt বন্ধ না করে ISR আর main-এর ভাগ করা word-এ |= লিখতে বলে | Compiler-এর -S output-এ LDR/ORR/STR দেখা; BSRR, critical section বা atomic নির্দেশ ব্যবহার |
AI-কে কাজে লাগাতে প্রসঙ্গ আর যাচাইয়ের শর্ত শুরুতেই দিন:
AI-এর উত্তর হাতে পেলে — যাচাইয়ের চেকলিস্ট
ভাবনার প্রশ্ন
প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন, তারপর “→ উত্তর” চাপুন।
প্র ০১ARM-এর বড় core-গুলো একসময় ৩২ বিটের “ARM” নির্দেশ আর ছোট “Thumb” নির্দেশ দুটিই চালাত। Cortex-M কেন শুধু Thumb রাখল, আর এর দাম কী?
আদি ARM নির্দেশ ছিল সবগুলো ৩২ বিটের, পরিষ্কার RISC নকশা, decode সহজ। কিন্তু নব্বইয়ের দশকে ARM যখন মোবাইল আর এমবেডেড যন্ত্রে ঢুকল, তখন একটি সমস্যা বড় হয়ে দেখা দিল: সেসব যন্ত্রের মেমরি ছোট আর দামি, আর ৩২ বিটের নির্দেশে কোড বড় হয়। ARM তাই Thumb আনল, প্রায় সব সাধারণ কাজের একটি ১৬ বিটের সংক্ষিপ্ত রূপ, যা CPU ভেতরে ৩২ বিটের নির্দেশে খুলে চালাত। দাম ছিল: ১৬ বিটে সব কাজ আঁটে না, তাই কঠিন অংশে program-কে আবার ARM state-এ যেতে হতো, আর দুই state-এর মধ্যে আসা-যাওয়া (interworking) programmer আর compiler-এর জন্য বাড়তি ঝামেলা।
Thumb-2 এই দ্বিধা মিটিয়ে দিল: একই নির্দেশ-প্রবাহে ১৬ আর ৩২ বিটের নির্দেশ মেশানো যায়, mode বদল ছাড়া। ৩২ বিটের Thumb-2 নির্দেশ দিয়ে প্রায় সব কাজ করা যায়, তাই আলাদা ARM state-এর আর দরকার থাকল না। ARMv7-M, অর্থাৎ Cortex-M3, এই সুযোগে ARM state পুরোপুরি বাদ দিল। ফলে decoder ছোট হলো, chip-এর জায়গা আর শক্তি বাঁচল, আর interworking-এর জটিলতা উধাও। এই পর্বের net_price() দেখুন: বারোটি নির্দেশের অর্ধেক ১৬ বিটের, বাকিগুলো যেখানে দরকার সেখানে ৩২ বিটের, মোট ৩৬ byte.
তবু অতীতের একটি চিহ্ন থেকে গেছে: ঠিকানার বিট ০. ARM আর Thumb state-এর পুরোনো জগতে লাফের ঠিকানার বিট ০ বলত কোন state-এ যেতে হবে। Cortex-M সেই নিয়ম রেখে দিয়েছে, যাতে পুরোনো toolchain আর কোড চলে। তাই vector table-এ handler-এর ঠিকানা বিজোড় (এই পর্বে 0x08000085), LR বিজোড় (0x0800011B), আর xPSR-এর T বিট সবসময় 1. কেউ ভুল করে বিট ০ = 0 ঠিকানায় লাফ দিলে CPU ARM state-এ যেতে চায়, যা M-core-এ নেই, আর ARMv7-M-এর নিয়মে UsageFault ওঠে (আলাদা fault মডেল না থাকায় কোর্সের board-এ সব fault HardFault-এ যায়, Spec decision 19). হাতে লেখা function pointer বা bootloader-এর লাফে এই ভুল খুব পরিচিত।
মূল উপলব্ধি: Thumb-2 ছোট কোড আর পূর্ণ ক্ষমতা একসঙ্গে দিয়েছে বলেই Cortex-M ARM state বাদ দিতে পেরেছে; পুরোনো জগতের একমাত্র অবশিষ্ট ঠিকানার বিট ০, যা ভুলে গেলে fault হয়।
প্র ০২8086 মেমরিতে সরাসরি যোগ করতে পারত, Cortex-M পারে না। Load/store নকশা কেন বেছে নেওয়া হলো, আর এমবেডেড firmware-এ এর কোন দিকটি সবচেয়ে বেশি ভোগায়?
Load/store নকশার মূল যুক্তি pipeline. যে নির্দেশ মেমরি থেকে পড়ে, হিসাব করে, আবার মেমরিতে লেখে, তার কাজের দৈর্ঘ্য অনিশ্চিত: মেমরি ধীর হলে পুরো নির্দেশ আটকে থাকে, আর মাঝখানে fault হলে কোন অর্ধেক হয়েছে তা সামলানো কঠিন। RISC-এর চিন্তা ছিল: প্রতিটি নির্দেশ একটি সরল কাজ করুক, হিসাব শুধু register-এ, মেমরির সঙ্গে লেনদেন শুধু load আর store-এ। তাহলে প্রতিটি নির্দেশ pipeline-এর ধাপে সমানভাবে আঁটে, decode সহজ, আর বেশি register রেখে মেমরিতে যাওয়ার প্রয়োজন কমানো যায়। Cortex-M-এর ষোলোটি ৩২ বিটের register এই ভাবনার ফল; net_price() একবারও মেমরি ছোঁয়নি।
Interrupt-এর দিক থেকেও লাভ আছে। প্রতিটি নির্দেশ ছোট বলে interrupt এলে CPU খুব তাড়াতাড়ি একটি নির্দেশ শেষ করে handler-এ যেতে পারে। (কিছু ব্যতিক্রম আছে, যেমন বহু register-এর LDM/STM, যা মাঝপথে থেমে পরে চালানো যায়; এর খবর রাখতে EPSR-এর ICI বিট ব্যবহার হয়।) কম ও স্থির latency microcontroller-এর জন্য খুব জরুরি।
কিন্তু এমবেডেড কাজে load/store-এর সবচেয়ে বড় ফাঁদ read-modify-write. C-তে GPIOA->ODR |= 1u << 5 এক লাইন, অথচ machine code-এ তিনটি নির্দেশ: পড়া, OR, লেখা। Main loop যদি PA5 (LED) জ্বালাতে গিয়ে ODR পড়ে, আর ঠিক তখনই একটি ISR PA6 (alarm) জ্বালিয়ে দেয়, তাহলে main-এর লেখা পুরোনো মান দিয়ে alarm আবার নিভিয়ে দেবে। বাজারঘরের cold room-এ এর মানে: তাপমাত্রা বেশি, অথচ alarm বাজছে না। এমন bug খুব কালেভদ্রে ঘটে, তাই পরীক্ষায় ধরা পড়া কঠিন। সমাধান কয়েকটি: শুধু-set আর শুধু-reset register (STM32-ধাঁচের BSRR, যা কোর্সের board-এও আছে), M3/M4-এ bit-banding, অল্প সময়ের জন্য interrupt বন্ধ, বা LDREX/STREX. কোনটি কখন, তা পর্ব ৩৫ আর ৪৩-এ।
মূল উপলব্ধি: Load/store নকশা pipeline আর interrupt-কে সরল ও দ্রুত করে, কিন্তু প্রতিটি “এক লাইনের” বিট বদলকে তিনটি আলাদা নির্দেশে ভাঙে; ISR আর main একই word ছুঁলে সেটি বুঝে নকশা করতেই হবে।
প্র ০৩Exception-এ আটটি register hardware নিজে stack করে, বাকি আটটি করে না। এই ভাগ কেন, আর এতে firmware লেখার ধরন কীভাবে বদলেছে?
8085 বা 8086-এ interrupt এলে CPU শুধু ফেরার ঠিকানা (আর 8086-এ FLAGS, CS) রাখত। বাকি সব register বাঁচানো ISR-এর দায়িত্ব, তাই ISR লিখতে হতো assembly-তে, বা compiler-এর বিশেষ “interrupt” keyword দিয়ে, যাতে শুরুতে PUSH আর শেষে POP বসে। Cortex-M-এর নকশাকারেরা একটি সূক্ষ্ম পর্যবেক্ষণ কাজে লাগালেন। ARM-এর calling convention (AAPCS) বলে, R0–R3, R12, LR আর flag একটি function ডাকলে নষ্ট হতে পারে; R4–R11 নষ্ট হবে না, কারণ ডাকা function সেগুলো বদলালে নিজেই বাঁচিয়ে ফিরিয়ে দেয়। তাহলে interrupt-এর সময় hardware যদি শুধু প্রথম দলটি (সঙ্গে PC আর xPSR) বাঁচায়, ISR-টি সাধারণ একটি C function হতে পারে, আর compiler নিয়মমাফিক R4–R11 সামলাবে।
এই পর্বের run ঠিক এটাই দেখিয়েছে: SysTick আসতেই SP 32 byte নেমেছে, frame-এ R0, R1, R2, R3, R12, LR, PC, xPSR, আর SysTick_Handler একটি সাধারণ C function, কোনো বিশেষ keyword ছাড়া। ফেরার জন্য LR-এ একটি “অসম্ভব” ঠিকানা, EXC_RETURN 0xFFFFFFF9, বসে; সাধারণ bx lr সেই ঠিকানায় লাফ দিতে গেলেই CPU বোঝে এটি আসলে ফেরার সংকেত, আর frame তুলে নেয়। Vector table-ও শুধু ঠিকানার তালিকা, যেখানে C function-এর নাম বসে (startup.c-র g_vectors).
এর ফল ব্যাপক। এমবেডেড firmware-এর প্রায় পুরোটা, ISR-সহ, এখন C-তে লেখা হয়; assembly লাগে শুধু খুব বিশেষ জায়গায়, যেমন RTOS-এর context switch, যেখানে বাকি আটটি register (R4–R11) হাতে বাঁচিয়ে PSP বদলাতে হয়। দাম হলো, প্রতিটি exception-এ আটটি word লেখা আর পড়া, যদিও ISR হয়তো তার অর্ধেকও ব্যবহার করে না; আর stack-এ সবসময় সেই জায়গা রাখতে হয়। ARM এই সময় কমাতে tail-chaining আর late arrival-এর মতো কৌশল যোগ করেছে, যা পর্ব ৩০-এ। আসল M3-এ entry-র সময় প্রায় ১২ cycle বলে ধরা হয়, তবে নির্দিষ্ট chip-এ flash আর bus-এর ওপর নির্ভর করে; কোর্সের board-এ এটি ০ cycle (Spec decision 17).
মূল উপলব্ধি: Hardware ঠিক সেই register-গুলো বাঁচায় যা C-র নিয়মে একটি function নষ্ট করতে পারে; এই মিলের জন্যই Cortex-M-এর ISR একটি সাধারণ C function.
প্র ০৪Cortex-M3-এ hardware ভাগের নির্দেশ থাকা সত্ত্বেও Clang ÷ 1000-কে গুণ আর shift-এ বদলাল। Compiler-এর এমন সিদ্ধান্ত firmware লেখকের জন্য কী শিক্ষা দেয়?
ভাগ CPU-র সবচেয়ে ধীর পূর্ণসংখ্যার কাজগুলোর একটি। Cortex-M3 TRM অনুযায়ী SDIV/UDIV-এর সময় ইনপুটভেদে কয়েক থেকে বারোটির মতো cycle, আর ৬৪ বিটের গুণ সাধারণত কম। ভাজক যখন একটি জানা constant, তখন compiler একটি পুরোনো গাণিতিক কৌশল খাটায়: x ÷ d ≈ x × ⌈2k ÷ d⌉ ÷ 2k, যেখানে k এমনভাবে বাছা যে সব সম্ভাব্য x-এ ফল হুবহু মেলে। এখানে k = 38, আর magic = 0x10624DD3. এই পর্বের Python ব্লক 1 থেকে 5000 g আর ৩২ বিটের কিনারায় একটিও অমিল পায়নি। এটি strength reduction-এর একটি উদাহরণ।
প্রথম শিক্ষা: C কোড আর machine code-এর মধ্যে সরাসরি এক-এক মিল নেই। “আমার কোডে ভাগ আছে, তাই ধীর” বা “এখানে ভাগ নেই, তাই দ্রুত” এমন অনুমান প্রায়ই ভুল। সত্য জানার উপায় একটিই: -S দিয়ে আসল output পড়া, আর সম্ভব হলে মাপা। Cortex-M0-এর মতো core-এ hardware divider নেই, তাই সেখানে চলকের ভাগ একটি library function ডাকে, যা অনেক বেশি সময় নেয়। পর্ব ২৮-এ একই C লাইন তিন core-এ compile করে এমন পার্থক্য দেখেছেন।
দ্বিতীয় শিক্ষা, আরও গুরুত্বপূর্ণ: optimizer আপনার কোডের অর্থ রক্ষা করে, কিন্তু সেই অর্থ C ভাষার নিয়মে। net * 6550 int32-এ হয়; net 327860 g ছাড়ালে signed overflow, যা C-তে undefined behavior, আর তখন compiler যা খুশি ধরে নিতে পারে। এখানে Clang UMULL (unsigned গুণ) ব্যবহার করেছে, কারণ cmp-এর পরে সে জানে net ধনাত্মক আর overflow “ঘটে না” বলে ধরে নিতে পারে। Scale-এর ৫ kg-এ কোনো সমস্যা নেই, কিন্তু একই function অন্য যন্ত্রে নিলে সীমা আবার হিসাব করতে হবে, বা int64_t নিতে হবে। ফিক্সড-পয়েন্ট হিসাবের এমন সীমা পর্ব ৪০-এ বিস্তারিত।
মূল উপলব্ধি: Compiler hardware-এর চেয়ে ভালো পথ খুঁজে নিতে পারে, কিন্তু তা করে C-র নিয়ম ধরে; তাই firmware লেখককে সংখ্যার সীমা নিজে নিশ্চিত করতে হয়, আর গতির দাবি আসল output দেখে করতে হয়।
প্র ০৫8086-এ কোনো সুরক্ষা ছিল না, অথচ ছোট্ট Cortex-M-এও privileged আর unprivileged ভাগ আছে। একটি microcontroller-এ এই ভাগের দরকার কোথায়, আর সীমা কী?
8086-এর যুগে একটি যন্ত্রে সাধারণত একটিই program চলত, আর সেটির হাতে সব ক্ষমতা। পরের x86-এ (80286 থেকে) সুরক্ষা এল, কারণ একসঙ্গে বহু program চলতে শুরু করল, আর একটির ভুল যেন অন্যটিকে না মারে। Microcontroller-এর জগৎ বহু বছর 8086-এর মতোই ছিল: একটি super loop, সবকিছু privileged. কিন্তু আজকের firmware অনেক বড়: একটি RTOS, Wi-Fi বা BLE stack, সেন্সরের driver, OTA update, আর কখনো তৃতীয় পক্ষের library. এর যেকোনো একটির ভুল pointer পুরো যন্ত্রকে থামিয়ে দিতে পারে, আর IoT যন্ত্রে নিরাপত্তার ছিদ্রও হতে পারে।
ARMv7-M এজন্য একটি সরল দুই-স্তরের ব্যবস্থা দেয়। Kernel আর ISR চলে privileged অবস্থায়; সাধারণ task চলে unprivileged অবস্থায়, যেখানে interrupt বন্ধ করা, NVIC বা SysTick ছোঁয়া বা CONTROL বদলানো যায় না। এই পর্বের run-এ unprivileged কোডের cpsid i আর CONTROL-এ লেখা সত্যিই নিষ্ফল হয়েছে। সঙ্গে MPU (Memory Protection Unit) থাকলে প্রতিটি task-কে মেমরির নির্দিষ্ট অংশে আটকে রাখা যায়। আর unprivileged থেকে privileged-এ ফেরার একমাত্র দরজা একটি exception, সাধারণত SVC: task অনুরোধ করে, kernel যাচাই করে কাজটি করে দেয়। বাজারঘরের cold-storage monitor-এ ধরুন alarm-এর task আর MQTT-র task আলাদা; network-এর কোডে ভুল হলেও alarm-এর অংশ যেন অক্ষত থাকে।
সীমাও আছে। ARMv7-M-এ MPU ঐচ্ছিক, region সংখ্যা কম (সাধারণত আটটির মতো), আর region-এর মাপ আর alignment-এর কড়া নিয়ম আছে, তাই নকশা কঠিন। বহু ছোট firmware সব কিছু privileged রেখেই চলে, যেমন এই কোর্সের board-এর example-গুলো। আরও শক্ত বিভাজনের জন্য ARMv8-M (Cortex-M33 ইত্যাদি) TrustZone এনেছে, যেখানে “secure” আর “non-secure” দুটি জগৎ, যেমন চাবি আর secure boot আলাদা রাখতে; এর এমবেডেড-নির্দিষ্ট দিক মডিউল ১৩-এ। আর মনে রাখবেন, কোর্সের board PSP আর SVC মডেল করে না (Spec decision 19), তাই পুরো RTOS-সুরক্ষার ছবি এখানে চালিয়ে দেখা যায় না।
মূল উপলব্ধি: Privilege-এর ভাগ বড় firmware-এর এক অংশের ভুলকে বাকিটা থেকে আলাদা রাখে; ARMv7-M তা দেয় সরল রূপে (দুই স্তর, SVC-র দরজা, ঐচ্ছিক MPU), আর ARMv8-M তাকে TrustZone পর্যন্ত বাড়িয়েছে।
অনুশীলন
প্রথমে নিজে লিখুন বা হিসাব করুন, তারপর উত্তর খুলুন। প্রতিটি উত্তর কোর্সের virtual board-এ বা Python-এ চালিয়ে যাচাই করা।
-
নকশা ও বাস্তবায়ন — লাফ ছাড়া net ওজন: Thumb-2 assembly-তে
clamp_net(gross, tare)লিখুন, যা gross − tare দেয়, কিন্তু ফল ঋণাত্মক হলে 0. AAPCS মেনে argument R0 আর R1-এ, ফল R0-এ। কোনো branch নির্দেশ (B,BLT) ব্যবহার করবেন না। (1400, 150), (150, 1400) আর (150, 150)-এ ফল কত?clamp_net: subs r0, r0, r1 @ net = gross - tare, flag বসে it lt @ পরের নির্দেশ শুধু "less than" হলে movlt r0, #0 @ ঋণাত্মক হলে 0 bx lrltমানে N ≠ V, অর্থাৎ signed অর্থে ছোট;mi(শুধু N = 1) লিখলে বিশাল মানে overflow হলে ভুল হতো। আমার lab-এরex.c-তে naked function হিসেবে বসিয়ে board-এ সত্যিকারের run:clamp_net(1400, 150) = 1250,clamp_net(150, 1400) = 0,clamp_net(150, 150) = 0. Board থেকে পড়া machine code1A40 BFB8 2000 4770: চারটি নির্দেশই ১৬ বিটের, মোট ৮ byte, কোনো লাফ নেই। -
ভুল খুঁজুন — ফিরতি পথ নেই: একজন RTOS-এর একটি task-কে সুরক্ষিত করতে লিখলেন:
msr control, r0(R0 = 1) দিয়ে unprivileged হওয়া, কাজ শেষেmsr control, r1(R1 = 0) দিয়ে আবার privileged হয়েcpsid i. তাঁর দাবি, “শেষে interrupt বন্ধ থাকবে।” ভুলটি কোথায়, আর ঠিক নকশা কী?Unprivileged অবস্থায় CONTROL-এ লেখা উপেক্ষিত হয়, তাই
msr control, r1কোনো কাজ করে না; ফলেcpsid i-ও unprivileged, সেটিও উপেক্ষিত। আমার lab-এরpriv.c-র সত্যিকারের run ঠিক এটাই দেখিয়েছে:try nPRIV=0: CONTROL=1আরcpsid i as unprivileged: PRIMASK=0. কোনো fault হয় না, তাই ভুলটি চুপচাপ থেকে যায়, যা আরও বিপজ্জনক। ঠিক নকশা: privileged অবস্থায় ফেরার একমাত্র দরজা একটি exception, সাধারণতSVC; তার handler (Handler mode, তাই privileged) কাজটি করবে বা CONTROL বদলাবে। কোর্সের board SVC মডেল করে না (Spec decision 19), তাই সেই অংশ এখানে চালানো হয়নি। -
আগে বলুন, তারপর মিলিয়ে দেখুন — দুটি ঋণাত্মকের যোগ: R0 = 0x80000000.
adds r0, r0, r0-এর পরে R0 আর N, Z, C, V কত? APSR কত হবে?0x80000000 + 0x80000000 = 0x1_00000000: নিচের ৩২ বিট 0, তাই R0 = 0, Z = 1, N = 0. বেরোনো বিট C-তে: C = 1. Signed অর্থে (−2147483648) + (−2147483648) = −4294967296, int32-এ আঁটে না, আর দুটি ঋণাত্মক থেকে “ধনাত্মক” (0) ফল: V = 1. তাই N Z C V = 0 1 1 1, APSR = 0x70000000. আমার lab-এর
ex.c-তে board-এর সত্যিকারের run:adds 0x80000000+0x80000000: r=0 NZCV=0111. 8086-এর 8000H + 8000H-এর মতোই (পর্ব ১৪-এর অনুশীলন): unsigned আর signed দুই অর্থেই overflow. -
হিসাব — xPSR আর bit-band: (ক) Debugger-এ xPSR = 0x6100000F দেখা গেল। CPU কোন mode-এ, কোন handler-এ, আর কোন flag 1? (খ) Cold room-এর alarm PA6, অর্থাৎ GPIOA ODR (0x4001080C)-এর বিট 6. একটি Cortex-M3 chip-এ এর bit-band alias কত? (গ) SRAM 0x20000400-এর বিট 2-এর alias কত?
(ক) নিচের ৯ বিট 0x00F = 15: Handler mode, SysTick-এর handler. বিট ২৪ (T) = 1. ওপরের nibble 0x6 =
0110: N = 0, Z = 1, C = 1, V = 0. এই পর্বেরxpsr.py-রdecode()একই ফল দেয়:APSR -ZC-- T=1 IT=0 IPSR=15 SysTick. (খ) 0x42000000 + (0x4001080C − 0x40000000) × 32 + 6 × 4 = 0x42000000 + 0x210180 + 0x18 = 0x42210198. (গ) 0x22000000 + 0x400 × 32 + 2 × 4 = 0x22000000 + 0x8000 + 0x8 = 0x22008008. দুটিইbitband.py-রbit_word()-এ মেলানো:0x42210198,0x22008008. মনে রাখবেন, কোর্সের virtual board-এ alias অঞ্চল নেই, তাই এই ঠিকানায় লিখলে সেখানে HardFault হবে; হিসাবটি আসল M3/M4 chip-এর জন্য, আর chip-এ bit-banding আছে কি না reference manual-এ দেখে নিতে হবে।
নিজেকে যাচাই করুন
ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।
ক্রমARM Cortex-M3-এ Thread mode-এ চলার সময় SysTick interrupt এলে ঘটনাগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)
- SysTick-এর counter 0-তে পৌঁছায়, exception pending হয়
- Hardware R0–R3, R12, LR, PC, xPSR (আট word) MSP-তে push করে
- LR-এ EXC_RETURN 0xFFFFFFF9 বসে, IPSR = 15
- Vector table-এর ১৫ নম্বর ঘর থেকে handler-এর ঠিকানা নিয়ে সেখানে লাফ
- Handler
bx lrকরে, hardware আট word তুলে নিয়ে Thread mode-এ ফেরে
ARM Cortex-M3-এ R13, R14 আর R15-এর কাজ যথাক্রমে কী?
- PC, LR, SP
- SP, LR, PC
- SP, xPSR, PC
- LR, CONTROL, PC
ARM Cortex-M-এ R0 = 150, R1 = 1400. subs r0, r0, r1-এর পরে N আর C কত?
- N = 0, C = 1
- N = 1, C = 1
- N = 1, C = 0
- N = 0, C = 0
ARM Cortex-M3-এ একটি handler-এর ভেতরে LR = 0xFFFFFFF9. এর অর্থ কী?
- Handler শেষে 0xFFFFFFF9 ঠিকানার কোডে লাফ দেবে
- Stack overflow হয়েছে, তাই LR নষ্ট
- ফিরে Thread mode-এ PSP ব্যবহার করবে
- এটি EXC_RETURN: ফিরে Thread mode-এ MSP নিয়ে চলবে
Cortex-M3-এ SRAM-এর ঠিকানা 0x20000000-এর বিট 3-এর bit-band alias কোন ঠিকানা?
- 0x2200000C
- 0x22000003
- 0x22000060
- 0x4200000C
ARM Cortex-M-এর load/store architecture সম্পর্কে কোন কথাটি ঠিক?
- ADD সরাসরি মেমরির একটি word-এ যোগ করতে পারে
- মেমরির মান বদলাতে LDR, হিসাব, তারপর STR লাগে
- Peripheral ছুঁতে IN আর OUT নির্দেশ লাগে
- Load/store নকশায় register কম রাখা হয়, কারণ সব হিসাব মেমরিতে
একটি Cortex-M3 chip-এর xPSR = 0x0100000F. এই মান থেকে কী বোঝা যায়?
- CPU Thread mode-এ, কোনো flag 1 নয়
- T বিট 1, তাই CPU ভুল state-এ আছে
- CPU HardFault handler-এ
- CPU SysTick-এর handler-এ, N Z C V সব 0
শব্দকোষ
লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:
মনে রাখুন
- Register: R0–R12 সাধারণ (R0–R3 argument, R0 ফল), R13 = SP (MSP/PSP), R14 = LR, R15 = PC; সব ৩২ বিট। বিশেষ register (xPSR, PRIMASK, CONTROL…) পড়া-লেখা
MRS/MSR-এ। - xPSR: APSR-এ N Z C V Q, EPSR-এ T আর IT, IPSR-এ exception নম্বর। শুধু S-ওয়ালা নির্দেশ আর CMP flag বদলায়; বিয়োগে C = 1 মানে borrow নেই।
- Thumb-2 আর load/store: ১৬ আর ৩২ বিট মেশানো; হিসাব register-এ, মেমরি শুধু LDR/STR-এ; IT block লাফ এড়ায়; ঠিকানার বিট ০ = 1 মানে Thumb.
- Mode: Thread (IPSR = 0) আর Handler (সবসময় privileged, সবসময় MSP); exception-এ আট word stack, LR = EXC_RETURN (0xFFFFFFF9: Thread, MSP).
- Pipeline আর bit-band: M3-এ Fetch–Decode–Execute; bit-band alias = base + offset × 32 + bit × 4, শুধু কিছু M3/M4 chip-এ, কোর্সের board-এ নেই।
আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ
- মাইক্রোপ্রসেসর, এমবেডেড সিস্টেম ও IoT · কোর্স হোম৮৫টি পর্বপুরো কোর্সের মানচিত্র আর বাজারঘরের দুটি device-এর পথ।
- পর্ব ১৪ · 8086-এর গঠনতুলনার জন্যSegment, queue আর নয়টি flag: Cortex-M-এর সঙ্গে পাশাপাশি পড়ুন।
- Computer Architecture পর্ব ২৫ · ISA কীপাশের ট্র্যাকRISC বনাম CISC আর load/store-এর সাধারণ তত্ত্ব।
- Computer Architecture পর্ব ২৬ · RISC-V-এর instructionপাশের ট্র্যাকআরেকটি load/store ISA, flag ছাড়া; Thumb-2-এর সঙ্গে তুলনা করুন।
- Programming Languages & Compilers পর্ব ৭১ · Calling convention আর ABIপাশের ট্র্যাকR0–R3, callee-saved register আর stack-এর চুক্তি কেন আর কীভাবে।