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

Embedded C — volatile, const, fixed-width integer আর optimization-এর ফাঁদ

Embedded C — volatile, const, Fixed-Width Integers and Optimization Traps

Taught in Bangla, this lesson shows what the optimizer assumes in freestanding firmware. Clang 22 at -O2 deletes one polling loop and turns another into an endless branch when an ISR flag lacks volatile; with volatile both exit at 100 ms on the course's virtual BG-M3 board. A race run shows volatile is not atomic (2284 lost increments, 0 with cpsid/cpsie). It compiles for Cortex-M3 and AVR to compare int sizes, demonstrates integer promotion pitfalls, places const tables in flash and lists MISRA-style habits.

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

  • OS ছাড়া চলা (freestanding) firmware-এর C কেন desktop-এর C থেকে আলাদা অভ্যাস চায়, তা বলতে পারা
  • Clang-এর আসল -O0 আর -O2 assembly পড়ে বোঝা, optimizer একটি polling loop-কে কেন মুছে দেয় বা আটকে দেয়
  • volatile-এর তিনটি সঠিক ব্যবহার (hardware register, ISR-এর সঙ্গে ভাগ করা data, setjmp/signal) আর তিনটি ভুল ধারণা (atomic, barrier, thread-এর সমাধান) আলাদা করা
  • const data কোথায় বসে, আর map file থেকে flash আর SRAM-এর খরচ পড়া
  • ৮ আর ১৬ বিটের হিসাবে integer promotion-এর ফল আগে থেকে বলা, আর MISRA-ধাঁচের অভ্যাসে এসব bug আগেই আটকানো

১ · এমবেডেড C কেন আলাদা — OS নেই, heap নেই, পাশে hardware আর ISR

মডিউল ৫-এ আপনি Cortex-M-এর ভেতরটা দেখেছেন: register, Thumb নির্দেশ আর exception (পর্ব ২৯)। এবার মডিউল ৬, যেখানে সেই chip-এর জন্য C লেখার কারিগরি। C ভাষা আপনি জানেন ধরে নিচ্ছি; না জানলে C প্রোগ্রামিং কোর্স আগে দেখুন, আর microcontroller-এ C-র প্রথম পরিচয় আছে C পর্ব ৫৪-এ। এখানে ভাষা নতুন করে শেখানো হবে না; শুধু সেই জায়গাগুলো, যেখানে এমবেডেড কাজে C-র নিয়ম হঠাৎ কামড় দেয়।

উপমা — বাজারঘরের হিসাবের খাতা: ক্যাশিয়ার সকালে গুদামঘরে গিয়ে আলুর বস্তা গুনে খাতায় লিখলেন “১২ বস্তা”। এরপর সারাদিন কেউ দাম জিজ্ঞেস করলে তিনি খাতা দেখেই বলেন, আবার গুদামে যান না; এতে সময় বাঁচে। কিন্তু দুপুরে পেছনের দরজা দিয়ে কর্মচারী নতুন বস্তা রেখে গেলেন (এটি ISR). খাতা জানে না, তাই ক্যাশিয়ার ভুল বলতে থাকেন। Compiler-এর optimizer এই ক্যাশিয়ার: একবার মেমরি থেকে register-এ এনে সেটিকেই সত্য ধরে নেয়। volatile হলো ক্যাশিয়ারকে বলা, “এই জিনিসটা যতবার জানতে চাওয়া হবে, ততবার গুদামে গিয়ে নিজের চোখে দেখবেন।”

Desktop-এ আপনার program চলে একটি অপারেটিং সিস্টেমের ওপর: main-এর আগে OS মেমরি সাজায়, printf লেখা পৌঁছে দেয় terminal-এ, malloc জায়গা দেয়, আর আপনার program হার্ডওয়্যার সরাসরি ছোঁয় না। এই পরিবেশকে C standard বলে hosted. Microcontroller-এর firmware চলে bare metal-এ, যাকে C standard বলে freestanding পরিবেশ। কোর্সের board-এর প্রতিটি build-এ তাই -ffreestanding -nostdlib flag থাকে (পর্ব ০৬)। পার্থক্যগুলো এক টেবিলে:

দিকDesktop (hosted)Firmware (freestanding)এমবেডেড অভ্যাস
main-এর আগেOS আর C runtimeনিজের reset handler: .data কপি, .bss শূন্যstartup কোড পড়ে বোঝা (পর্ব ৩২)
main থেকে ফেরাprogram শেষফেরার জায়গা নেইএকটি super loop, কখনো শেষ হয় না
মেমরিGB, virtual memory20 KiB SRAM, 128 KiB flash (board)heap এড়ানো, static বরাদ্দ (পর্ব ৩৯)
HardwareOS-এর driver-এর আড়ালেনির্দিষ্ট ঠিকানায় registermemory-mapped I/O, volatile pointer
একসঙ্গে চলা কোডthread, OS-এর lockISR, যেকোনো নির্দেশের মাঝে ঢুকে পড়েভাগ করা data-য় volatile + সুরক্ষা
ভুল হলেOS program বন্ধ করে, বার্তা দেয়যন্ত্র আটকে যায় বা HardFaultwatchdog, fault handler (পর্ব ৬১)

শেষ দুই সারিই এই পর্বের মূল কারণ। Desktop-এর একটি সাধারণ program-এ (thread ছাড়া) আপনার কোড ছাড়া আর কেউ আপনার variable বদলায় না। Firmware-এ বদলায় দুজন: hardware নিজে (UART-এর status register-এ “byte এসেছে” বিট বসে যায়), আর ISR, যে main-এর যেকোনো দুই নির্দেশের মাঝে ঢুকে মেমরিতে লিখে বেরিয়ে যায়। Compiler এই দুজনের কথা জানে না, যদি না আপনি বলে দেন। আর বলার ভাষাই volatile.

২ · Fixed-width integer — stdint.h আর int-এর মাপের অনিশ্চয়তা

C standard int-এর মাপ বেঁধে দেয়নি; শুধু বলেছে এটি অন্তত ১৬ বিট। ফলে একই C কোড এক chip-এ এক রকম, আরেক chip-এ আরেক রকম আচরণ করতে পারে। নিচের তিন লাইন একই Clang 22.1.8 দিয়ে দুটি target-এ compile করা হলো: কোর্সের Cortex-M3 (--target=thumbv7m-none-eabi) আর AVR-এর ATmega328P (--target=avr-none -mmcu=atmega328p, Arduino Uno-র chip).

#include <stdint.h>
const int int_bits = sizeof(int) * 8;
uint32_t twice(uint16_t w) { return w * 2; }
সত্যিকারের run — clang -S -O2 (ziglang 0.17.1, Clang 22.1.8)
--- thumbv7m (Cortex-M3) ---          --- avr (ATmega328P) ---
twice:                                twice:
        lsls    r0, r0, #1                    movw    r22, r24
        bx      lr                            lsl     r22
int_bits:                                     rol     r23
        .long   32                            ldi     r24, 0
                                              ldi     r25, 0
                                              ret
                                      int_bits:
                                              .short  16

Cortex-M-এ int ৩২ বিট, AVR-এ ১৬ বিট। আর ফলও আলাদা: Cortex-M w-কে ৩২ বিটের register-এ এক বিট বাঁয়ে সরায়, তাই 40000 × 2 = 80000. AVR-এ uint16_t-এর হিসাব হয় ১৬ বিটের unsigned int-এ: lsl/rol দুটি byte সরায়, ওপরের দুই byte সোজা 0 (ldi r24, 0), তাই ফল 80000 − 65536 = 14464. কেন এমন হয়, তা অংশ ৭-এ।

এর সমাধান C99 (১৯৯৯) এনেছে stdint.h-এ: যে টাইপের নামেই মাপ লেখা। uint8_t ঠিক ৮ বিট চিহ্নহীন, int16_t ঠিক ১৬ বিট চিহ্নসহ, uint32_t ঠিক ৩২ বিট। এমবেডেড কাজে নিয়মটি সরল:

কাজটাইপকেন
৩২ বিটের peripheral registervolatile uint32_tregister-এর মাপ ঠিক ৩২ বিট; bazarghar.h-এর সব register এভাবে
UART-এর একটি byte, I2C-র datauint8_tprotocol-এ byte-ই একক
Scale-এর ADC count (0–4095)uint16_t বা uint32_t১২ বিটের মান; হিসাবে বড় টাইপে নেওয়া নিরাপদ
Cold room-এর তাপমাত্রা (0xFF80 = −0.50 °C)int16_tsensor-এর two's complement ১৬ বিট (পর্ব ০৫)
দাম পয়সায় (8188 = 81.88 টাকা)int32_tnet_g × 6550 ১৬ বিটে আঁটে না
লুপের গণনা, সাধারণ হিসাবuint32_t বা intCortex-M-এ ৩২ বিটই স্বাভাবিক মাপ

শেষ সারির পাশে একটি টীকা: stdint.h-এ uint_fast8_t (“অন্তত ৮ বিট, এই chip-এ যেটা সবচেয়ে দ্রুত”) আর uint_least8_t (“অন্তত ৮ বিট, যেটা সবচেয়ে ছোট”) ধাঁচের টাইপও আছে। Cortex-M-এ ৮ বিটের local variable-এ অনেক সময় বাড়তি নির্দেশ লাগে, কারণ register ৩২ বিটের আর ফলকে ৮ বিটে কেটে রাখতে হয়। টাইপের সাধারণ পরিচয় C পর্ব ০৬-এ; এখানে শুধু এমবেডেড দিক।

৩ · Optimizer কী ধরে নেয় — একটি polling loop-এর তিন রকম ভাগ্য

Compiler-এর optimization একটি নিয়ম মেনে চলে, যাকে বলে as-if rule: program-এর দেখা যায় এমন আচরণ (I/O, volatile access) যদি একই থাকে, তাহলে ভেতরে যা খুশি বদলানো যায়। দেখা যায় না এমন সব কিছুতে, যেমন একটি সাধারণ global variable কতবার মেমরি থেকে পড়া হলো, compiler স্বাধীন। আর compiler ধরে নেয়, যে function সে compile করছে, তার চলার মাঝে অন্য কেউ সেই variable বদলায় না। ISR-এর অস্তিত্ব সে জানে না: SysTick_Handler তার চোখে আর দশটা function-এর মতো, যাকে main কোথাও ডাকে না।

এবার বাজারঘরের smart scale-এর একটি টুকরো। SysTick প্রতি 1 ms-এ interrupt দেয়; ISR প্রতি 100 ms-এ একটি flag তোলে, আর main loop সেই flag-এর অপেক্ষায় polling করে, তারপর ADC পড়ে। Scale-এর README অনুযায়ী মাপ প্রতি 100 ms-এ একবার। আমার lab-এর wait_common.c (reference lab-এর scale.c-র কাঠামো থেকে ছোট করা):

static SHARED uint32_t ms_ticks;     /* ISR লেখে */
static SHARED uint32_t sample_due;   /* ISR -> main flag */

void SysTick_Handler(void)
{
    ms_ticks++;
    if (ms_ticks % 100u == 0u)
        sample_due = 1;
}
/* main()-এর ভেতরে, SysTick 1 ms-এ চালু করার পরে: */
    for (uint32_t n = 1; n <= 3; n++) {
        while (!sample_due) { }                  /* loop A */
     /* for (;;) { if (sample_due) break; }         loop B */
        sample_due = 0;
        uint32_t raw = adc_read();
        /* UART-এ "sample n raw=... t=... ms" */
    }

SHARED একটি macro: wait_bad.c-তে খালি, wait_ok.c-তে volatile. Loop A আর B দেখতে আলাদা হলেও C-র অর্থে একই কাজ করে। চারটি firmware board-এ চালানো হলো, ১৫০ g ওজন রেখে (scale150.json):

সত্যিকারের run — board.py (BG-M3), Clang 22.1.8 -O2
== loop A, volatile ছাড়া
[     0.0265 ms] UART: waiting for sample_due ...
[     0.0671 ms] UART: sample 1 raw=505 t=0 ms
[     0.1075 ms] UART: sample 2 raw=505 t=0 ms
[     0.1479 ms] UART: sample 3 raw=505 t=0 ms
[     0.1487 ms] exit(0) after 1190 cycles
== loop B, volatile ছাড়া   (--cycles 8000000)
[     0.0269 ms] UART: waiting for sample_due ...
[  1000.0000 ms] stopped: cycle limit (8000000) reached after 8000000 cycles
== loop A বা B, volatile সহ  (দুটির output হুবহু এক)
[     0.0269 ms] UART: waiting for sample_due ...
[   100.0526 ms] UART: sample 1 raw=505 t=100 ms
[   200.0521 ms] UART: sample 2 raw=505 t=200 ms
[   300.0523 ms] UART: sample 3 raw=505 t=300 ms
[   300.0531 ms] exit(0) after 2400425 cycles

তিন রকম ভাগ্য। volatile সহ দুটি loop-ই ঠিক 100, 200, 300 ms-এ মাপ নিয়েছে (raw = 505 মানে ১৫০ g, README-র load-cell সূত্রে 400 + 0.7 × 150). Loop A volatile ছাড়া একেবারেই অপেক্ষা করেনি: ০.১৫ ms-এ তিনটি “মাপ”, সবগুলো t = 0. আর loop B চিরকাল আটকে আছে; board থেমেছে শুধু আমার দেওয়া cycle সীমায় (--cycles 8000000 = 1000 ms). আরও অদ্ভুত: -O0-এ (optimization বন্ধ) volatile ছাড়াও দুটি loop ঠিকঠাক 100.1300 ms, 200.13… ms-এ মাপ নিয়েছে। “Debug build-এ চলে, release build-এ চলে না”, এমবেডেড জগতের পুরোনো অভিযোগ, ঠিক এখান থেকে আসে।

ছবি ৩৪.১ — ISR লেখে SRAM-এ, main পড়ে কোথা থেকে?

ওপরে volatile ছাড়া (-O2, loop B): flag একবারই পড়া হয়; নিচে volatile সহ: প্রতিটি ঘোরায় নতুন করে পড়া

volatile ছাড়া আর সহ polling loop ক) volatile ছাড়া, -O2 (loop B) খ) volatile সহ, -O2 SysTick ISR100 ms-এ লেখে 1 SRAMsample_due = 1 main · R0R0 = 0 (পুরোনো) SysTick ISR100 ms-এ লেখে 1 SRAMsample_due = 1 main · R0R0 = 1 → বেরোয় ldrb একবার b . — চিরকাল, SRAM আর পড়ে না SRAM-এ 1, অথচ R0-এ পুরোনো 0 প্রতিটি ঘোরায় ldr r0,[r6] (0x080000D8 … 0x080000E8) 100.0526 ms-এ “sample 1”, 300 ms-এ শেষ
ছবি ৩৪.১ — ঠিকানা আর মান board-এর সত্যিকারের run থেকে। ওপরের ভাগে loop B-এর b . নির্দেশ 0x08000230-এ (machine code E7FE); নিচের ভাগে loop 0x080000D8 থেকে 0x080000E8 পর্যন্ত।

কেন এমন হলো, তা বলবে আসল assembly. প্রথমে loop B, volatile ছাড়া, তিনটি অবস্থায় (আমার lab-এর asm.py, যা clang -S --target=thumbv7m-none-eabi -mcpu=cortex-m3 -fno-sanitize=undefined চালায়, zig cache নিজের lab-এ):

সত্যিকারের run — loop B-এর অংশ, Clang 22.1.8
-O0, volatile ছাড়া          -O2, volatile ছাড়া           -O2, volatile সহ
.LBB1_3:                     ldrb  r0, [r6]   @ একবার    .LBB1_1:
  movw r0, :lower16:sample_due cmp r0, #0                  ldr  r0, [r6]
  movt r0, :upper16:sample_due beq.w .LBB1_17              cbnz r0, .LBB1_5
  ldr  r0, [r0]   @ প্রতিবার   ...                         ldr  r0, [r6]
  cbz  r0, .LBB1_5           .LBB1_17:                     cbnz r0, .LBB1_5
  b    .LBB1_4                 b    .LBB1_17  @ b .        ldr  r0, [r6]
.LBB1_5:                                                   cbnz r0, .LBB1_5
  b    .LBB1_3                                             ldr  r0, [r6]
                                                           cmp  r0, #0
                                                           beq  .LBB1_1

-O0-এ compiler প্রতিটি C কাজ আক্ষরিক অনুবাদ করে: প্রতি ঘোরায় ঠিকানা বানিয়ে ldr. তাই volatile না থাকলেও কাজ করে, কিন্তু সেটি সৌভাগ্য, নিশ্চয়তা নয়। -O2-এ volatile ছাড়া optimizer যুক্তি দেয়: “loop-এর ভেতরে কেউ sample_due বদলায় না, তাই একবার পড়লেই যথেষ্ট।” এর নাম hoisting, অর্থাৎ loop-এর ভেতরের একই ফলের কাজ বাইরে তোলা। একবার পড়ে 0 পেলে লাফ .LBB1_17-এ, যেখানে একটিই নির্দেশ: নিজের দিকে লাফ, একটি infinite loop. volatile দিলে প্রতিটি ldr ফিরে আসে; বাড়তি হিসেবে compiler loop-টি চারবার পাশাপাশি লিখেছে (loop unrolling), যা অর্থ বদলায় না।

আরেকটি খুঁটিনাটি চোখে পড়ার মতো: volatile ছাড়া build-এ পড়াটা ldrb, এক byte! Board-এর মেমরিতেও sample_due-এর আকার ১ byte পাওয়া গেছে (volatile build-এ ৪). Optimizer দেখেছে এই variable-এ শুধু 0 আর 1 বসে, তাই নিজে থেকেই তাকে এক byte-এর bool বানিয়েছে। Volatile variable-এ compiler এমন কিছু করতে পারে না: আপনি যে মাপ লিখেছেন, ঠিক সেই মাপেই পড়া-লেখা হয়।

আর loop A? -O2, volatile ছাড়া build-এর assembly-তে sample_due variable-টিই নেই (শুধু UART-এর বার্তার লেখায় নামটি আছে): main-এ কোনো পড়া নেই, ISR-এ কোনো লেখা নেই। ISR শুধু ms_ticks++ করে। এর পেছনে C11-এর একটি নিয়ম (§6.8.5 অনুচ্ছেদ ৬): যে loop-এর শর্ত একটি ধ্রুবক নয়, আর যার ভেতরে কোনো I/O, volatile access বা synchronization নেই, compiler সেটি “একসময় শেষ হবে” বলে ধরে নিতে পারে। Optimizer-এর যুক্তি: flag একবার পড়ে 0 হলে loop কখনো শেষ হবে না, যা নিয়মে অসম্ভব; তাই flag নিশ্চয়ই 1, অতএব loop বাদ। তখন sample_due-এর আর কোনো পাঠক নেই, তাই ISR-এর লেখাও মুছে গেছে (dead code elimination). Loop B-এর শর্ত for (;;), একটি ধ্রুবক, তাই সেখানে এই অনুমান খাটে না, আর ফল চিরকালের অপেক্ষা। দুই পথই ভুল, শুধু ভুলের চেহারা আলাদা।

Board-এর অবস্থা
Board-এর সময়
ISR
SRAM-এ sample_due
volatile ছাড়া: PC · R0
volatile সহ: PC · R0
  1. Loop-এ ঢোকা। SRAM-এ sample_due = 0. Volatile ছাড়া build একবার ldrb r0,[r6] পড়ে R0 = 0 পায়, আর beq.w তাকে 0x08000230-এ পাঠায়। Volatile build-ও প্রথম ldr-এ 0 পায়, cbnz লাফায় না।
  2. প্রথম ৯৯টি tick. SysTick প্রতি 1 ms-এ ISR চালায়, ms_ticks বাড়ে, flag 0-ই থাকে। Volatile ছাড়া CPU 0x08000230-এর b . (E7FE) চালাচ্ছে, নিজের দিকে লাফ। Volatile build 0x080000D8–0x080000E8-এর loop-এ প্রতিবার SRAM পড়ছে।
  3. 100 ms: ISR flag তুলল। ms_ticks = 100, ভাগশেষ 0, তাই SRAM-এ sample_due = 1. Volatile build-এর পরের ldr 1 পায়, cbnz loop থেকে বের করে দেয়। Volatile ছাড়া build SRAM আর পড়েই না, তাই কিছুই টের পায় না।
  4. প্রথম মাপ। Volatile build flag 0 করে, ADC পড়ে, 100.0526 ms-এ ছাপে sample 1 raw=505 t=100 ms. অন্যটি তখনো 0x08000230-এ, SRAM-এ তার flag 1 হয়ে বসে আছে।
  5. 1000 ms: board-এর সীমা। Volatile build 300.0531 ms-এই তিনটি মাপ শেষ করে বেরিয়ে গেছে। অন্যটিকে board থামাল; আমার lab-এর peek.py তখন SRAM পড়ে পেল ms_ticks = 999 আর sample_due = 1, PC = 0x08000230. ISR ঠিকই কাজ করেছে; main শুধু আর তাকায়নি।

সাবধান — “-O0-এ চলে” কোনো প্রমাণ নয়: Optimization বন্ধ রাখলে bug লুকিয়ে থাকে, চলে যায় না। একই কোড পরে compiler-এর নতুন version, অন্য flag বা আশপাশের কোড বদলালে ভেঙে যেতে পারে। Volatile ছাড়া ভাগ করা variable C-র নিয়মে একটি data race, অর্থাৎ undefined behavior; ফল কী হবে, standard কিছুই বলে না। সাধারণ UB-এর আলোচনা C পর্ব ৪৮-এ, আর loop-এর optimization-এর তত্ত্ব Programming Languages & Compilers পর্ব ৬৬-এ।

৪ · volatile কী করে — প্রতিটি পড়া-লেখা সত্যিই ঘটবে

volatile একটি type qualifier. এর মূল প্রতিশ্রুতি একটি: volatile বস্তুর প্রতিটি পড়া আর লেখা C-র abstract machine-এ যেমন লেখা, ঠিক তেমনই, ঠিক ততবার আর একে অপরের সাপেক্ষে সেই ক্রমেই ঘটবে। C standard volatile access-কে একটি “side effect” বলে গণ্য করে, যেমন একটি I/O. ফলে compiler পড়া বাদ দিতে পারে না, দুটি লেখাকে একটিতে মেলাতে পারে না, আর মাপ বদলাতে পারে না। এমবেডেড কাজে এর তিনটি আসল ব্যবহার:

১. Hardware register

ADC-র SR-এ EOC বিট hardware নিজে বসায়; UART-এর DR পড়লে একটি byte সরে যায়। কোর্সের bazarghar.h-এ তাই প্রতিটি register __IO = volatile. ঠিকানা থেকে register বানানোর পুরো কৌশল পর্ব ৩৬-এ।

২. ISR-এর সঙ্গে ভাগ করা data

ISR লেখে, main পড়ে (বা উল্টো): flag, tick counter, ring buffer-এর index. ওপরের sample_due-এর মতো। এখানে volatile দরকার, কিন্তু যথেষ্ট নয় (অংশ ৫)।

৩. setjmp আর signal

Desktop C-তেও দুটি জায়গা: setjmp-এর পরে বদলানো local variable, আর signal handler-এর volatile sig_atomic_t flag. দুটিই “চোখের আড়ালে বদল”।

বাজারঘরের scale-এর ADC পড়ার function-টি দেখুন, reference lab-এর scale.c থেকে হুবহু:

static uint32_t adc_read(void)
{
    ADC1->CR = ADC_CR_ADON | ADC_CR_SWSTART;     /* রূপান্তর শুরু */
    while ((ADC1->SR & ADC_SR_EOC) == 0) { }      /* EOC-এর অপেক্ষা */
    return ADC1->DR;                             /* পড়লে EOC মুছে যায় */
}

এখানে কোনো ভাগ করা variable নেই, তবু volatile অপরিহার্য। SR volatile না হলে loop-টি অংশ ৩-এর মতো মুছে যেত বা আটকে যেত। আর DR পড়া একটি কাজ: board-এ (Spec decision 25) আর বহু আসল chip-এ data register পড়লে status বিট মুছে যায়। Compiler যদি “ফল তো ব্যবহারই হয়নি” বলে একটি পড়া বাদ দেয়, hardware-এর অবস্থা বদলাবে না। এই কারণে volatile register-এর একটি অকাজের মতো দেখতে পড়াও ((void)UART->DR;) আসলে কাজের: পুরোনো byte ফেলে দেওয়া।

ISR-এর দিকেও খরচ আছে। wait_ok.c-র ISR-এর -O2 output-এ ms_ticks লেখার ঠিক পরে আবার পড়া হয়েছে, কারণ C-তে ms_ticks++ আর ms_ticks % 100u দুটি আলাদা access:

সত্যিকারের run — SysTick_Handler, -O2
volatile ছাড়া                      volatile সহ
  ldr   r1, [r0]                      ldr   r1, [r0]
  ...                                 adds  r1, #1
  str   r1, [r0]   @ একবার লেখা       str   r1, [r0]
                                      ldr   r0, [r0]   @ আবার পড়া

সাধারণত এটি নগণ্য, কিন্তু একটি ISR-এ বারবার একই volatile বস্তু ছুঁলে নিয়মটি মনে রাখার মতো: একবার একটি local variable-এ কপি নিন, তাতে হিসাব করুন, শেষে একবার লিখুন। তাতে access-এর সংখ্যা আপনার নিয়ন্ত্রণে থাকে।

Pointer-এর সঙ্গে volatile-এর জায়গাটিও পরীক্ষায় আসে। volatile uint32_t *p মানে “p যেখানে দেখায়, সেই মান volatile”, register-এর জন্য এটিই চাই। uint32_t * volatile p মানে pointer নিজেই volatile, যেমন ISR যে pointer বদলায়। দুটি একসঙ্গেও হয়। আর const volatile কোনো স্ববিরোধ নয়: “আমার কোড লিখবে না, কিন্তু মান বদলাতে পারে”, যেমন একটি read-only status register; bazarghar.h-এর __I ঠিক তাই।

৫ · volatile কী করে না — atomic নয়, barrier নয়

সবচেয়ে প্রচলিত ভুল ধারণা: “volatile দিলেই ISR-এর সঙ্গে ভাগ করা variable নিরাপদ।” Cortex-M একটি load/store architecture (পর্ব ২৯), তাই shared++ সবসময় তিনটি নির্দেশ: পড়া, যোগ, লেখা, অর্থাৎ একটি read-modify-write. Volatile নিশ্চিত করে তিনটিই ঘটবে; কিন্তু মাঝখানে ISR ঢুকবে না, এমন কোনো কথা দেয় না। পরীক্ষাটি board-এ করা হলো: আমার lab-এর race.c-তে main ১,০০,০০০ বার shared++ করে, আর SysTick প্রতি 100 cycle-এ (LOAD = 99) একটি ISR চালায়, যা নিজেও shared++ করে আর isr_hits গোনে। দুজনের যোগফল 100000 + isr_hits হওয়ার কথা।

static volatile uint32_t shared;     /* main আর ISR দুজনেই +1 */
static volatile uint32_t isr_hits;

void SysTick_Handler(void) { shared++; isr_hits++; }

    for (uint32_t i = 0; i < 100000u; i++)
        shared++;                          /* LDR, ADD, STR */
    /* ... তারপর একই কাজ, কিন্তু সুরক্ষাসহ: */
    for (uint32_t i = 0; i < 100000u; i++) {
        __disable_irq();                   /* cpsid i */
        shared++;
        __enable_irq();                    /* cpsie i */
    }
সত্যিকারের run — board.py run build/race.elf
[    43.1001 ms] UART: volatile only:    shared=101156 expected=103440 lost=2284
[   141.4932 ms] UART: with cpsid/cpsie: shared=107865 expected=107865 lost=0
[   141.4940 ms] exit(0) after 1131952 cycles

শুধু volatile দিয়ে 3440টি ISR-এর মধ্যে 2284টির যোগ হারিয়ে গেছে, প্রায় দুই-তৃতীয়াংশ। PRIMASK দিয়ে interrupt বন্ধ রেখে করলে একটিও হারায়নি। (দ্বিতীয় অংশে ISR বেশিবার চলেছে, কারণ loop-এ নির্দেশ বেশি, তাই সময়ও বেশি।) কীভাবে একটি যোগ হারায়, তা আমার lab-এর lost.py ধরেছে: এটি board.py-র exception-এ ঢোকার মুহূর্তে register পড়ে, আর shared-এর প্রতিটি লেখা নথিভুক্ত করে। প্রথম হারানো যোগটি নিচে, নির্দেশ ধরে ধরে:

mainldr r1,[r7]mainadd.w r1,r1,#1mainstr r1,[r7]ISRldr r1,[r0]ISRadds r1,#1ISRstr r1,[r0]
নির্দেশের পরে
কে চলছে
main-এর R1
ISR-এর R1
SRAM-এ shared
হওয়া উচিত
  1. main পড়ল। ldr r1,[r7]: SRAM-এর shared = 62, main-এর R1-এ এখন তার কপি 62.
  2. SysTick এল, cycle 239-এ। main 0x0800019C-এর add.w-এর ঠিক আগে থামল। Hardware R0–R3, R12, LR, PC, xPSR stack-এ রাখল; main-এর R1 = 62 সেই frame-এ নিরাপদ।
  3. ISR পড়ল আর যোগ করল। ISR-এর নিজের ldr SRAM থেকে 62 পায়, adds-এ 63. এখন দুজনের হাতেই একই পুরোনো মান থেকে বানানো ফল।
  4. ISR লিখল, ফিরে গেল। SysTick_Handler+0xC-এর str SRAM-এ 63 লিখল, ঠিক যা হওয়া উচিত। ফেরার সময় hardware stack থেকে main-এর R1 = 62 ফিরিয়ে দিল।
  5. main যোগ করল। add.w: R1 = 62 + 1 = 63. main জানে না যে SRAM-এর মান ইতিমধ্যে বদলে গেছে; তার হাতের কপি পুরোনো।
  6. main লিখল — একটি যোগ হারাল। 0x080001A0-এর str SRAM-এ 63 লিখল, ISR-এর লেখা মুছে। দুটি ++-এর পরে হওয়ার কথা 64, আছে 63. Volatile এখানে ঠিক কাজই করেছে: প্রতিটি পড়া-লেখা সত্যিই ঘটেছে। সমস্যা ক্রমে, যা volatile-এর এক্তিয়ারের বাইরে।

দুই-তৃতীয়াংশ কেন? তিনটি নির্দেশের তিনটি ফাঁকের মধ্যে দুটি বিপজ্জনক: LDR-এর পরে আর ADD-এর পরে। নিচের ব্লক board-এর মতো একটি সরল মডেল চালায় (১ নির্দেশ = ১ cycle, প্রতি 100 cycle-এ ১২ নির্দেশের ISR). এটি আসল board নয়, শুধু হিসাবের যুক্তি যাচাই।

# volatile shared++ = LDR, ADD, STR. প্রতি 100 cycle-এ SysTick ISR-ও shared++ করে।
PERIOD, ISR_LEN, N = 100, 12, 100_000      # LOAD = 99; ISR-এ ১২টি নির্দেশ

def run(protect):
    shared = hits = cycle = 0
    next_tick = PERIOD
    first = None
    for _ in range(N):
        for step in ("ldr", "add", "str"):
            inside = step != "ldr"          # LDR হয়ে গেছে, STR এখনো বাকি
            if cycle >= next_tick and not (protect and inside):
                if inside and first is None:
                    first = (cycle, r1, shared)
                shared += 1; hits += 1          # ISR-এর shared++
                cycle += ISR_LEN; next_tick += PERIOD
            if step == "ldr":
                r1 = shared                     # main-এর কপি register-এ
            elif step == "add":
                r1 += 1
            else:
                shared = r1                     # পুরোনো কপি দিয়ে লেখা
            cycle += 1
    return shared, hits, first

for protect in (False, True):
    shared, hits, first = run(protect)
    lost = N + hits - shared
    name = "cpsid/cpsie" if protect else "volatile only"
    print(f"{name:13}: shared={shared} expected={N + hits} lost={lost}"
          f" ({lost / hits:.2f} of {hits} ticks)")
    if first:
        print(f"  first loss at cycle {first[0]}: main R1={first[1]}, shared={first[2]}")

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

volatile only: shared=101136 expected=103408 lost=2272 (0.67 of 3408 ticks)
  first loss at cycle 100: main R1=33, shared=33
cpsid/cpsie  : shared=103408 expected=103408 lost=0 (0.00 of 3408 ticks)

মডেলে হারানোর হার 0.67, board-এ 2284 ÷ 3440 = 0.664: দুই-তৃতীয়াংশের যুক্তি মিলেছে। সংখ্যা হুবহু এক নয়, কারণ আসল loop-এ Clang ৩২টি ++ পাশাপাশি লিখেছে আর মাঝে loop-এর গণনার নির্দেশ আছে, যা মডেলে নেই। মূল কথা দুটি: ক্ষতি “কদাচিৎ” নয়, প্রায় প্রতিবার; আর ক্ষতির পরিমাণ নির্ভর করে ঠিক কোন নির্দেশে interrupt এল তার ওপর, তাই সাধারণ পরীক্ষায় এমন bug ধরা পড়ে না, মাঠে পড়ে।

ঠিক করার উপায় কয়েকটি। ছোট critical section: __disable_irq() থেকে __enable_irq() পর্যন্ত যতটা সম্ভব ছোট। Cortex-M3/M4-এ (ARMv7-M) LDREX/STREX দিয়ে একটি atomic operation, যা C11-এর <stdatomic.h> ব্যবহার করলে compiler নিজেই বানায়; Cortex-M0-এ (ARMv6-M) এই নির্দেশ নেই। অথবা নকশা বদলানো: একজনই লিখবে, অন্যজন শুধু পড়বে। Cortex-M3-এ একটি aligned ৩২ বিটের পড়া একটি LDR, তাই শুধু-পড়া নিরাপদ; ৮ বিটের AVR-এ একই uint32_t পড়তে চারটি নির্দেশ লাগে, আর মাঝে ISR এলে অর্ধেক পুরোনো, অর্ধেক নতুন মান। ISR নকশার এই খুঁটিনাটি পর্ব ৪৩-এ (Interrupt আর ISR নকশা), আর register-এর বিট বদলের একই সমস্যা পর্ব ৩৫-এ (Register-এর bit manipulation).

Barrier-ও নয়

দ্বিতীয় ভুল ধারণা: volatile লেখার আগের সব কাজ শেষ হয়ে যাবে। নিয়মটি শুধু volatile access-গুলোর পারস্পরিক ক্রম রক্ষা করে। ধরুন main একটি সাধারণ (volatile নয়) buffer-এ cold room-এর ১০টি reading লিখে শেষে volatile flag ready = 1 দিল, আর ISR flag দেখে buffer পাঠাবে। Compiler চাইলে buffer-এর কিছু লেখা flag-এর পরে সরাতে পারে, কারণ buffer volatile নয়। এ জন্য দরকার একটি compiler barrier: bazarghar.h-এর __disable_irq(), __WFI()-এ "memory" clobber ঠিক এই কাজ করে। আর বহু-core chip বা Cortex-M7-এর মতো জটিল bus-এ CPU নিজেও লেখার ক্রম বদলাতে পারে; তখন DMB-এর মতো memory barrier নির্দেশ লাগে। ARM এ বিষয়ে Cortex-M-এর জন্য একটি আলাদা application note প্রকাশ করেছে; নিজের chip-এর জন্য সেটি আর reference manual মিলিয়ে নিন। Thread-এর জগতে atomic আর memory ordering-এর তত্ত্ব আছে Operating Systems পর্ব ২৩-এ।

৬ · const আর flash — টেবিল কোথায় বসে, আর লিখতে গেলে কী হয়

Desktop-এ const মানে মূলত “compiler, আমাকে ভুল করে বদলাতে দেওয়া চলবে না”। Microcontroller-এ এর একটি বড় বাস্তব ফল আছে: জায়গা। ধরুন বাজারঘরের scale-এ তিনটি পণ্যের দর পয়সায়: আলু 6550, পেঁয়াজ 4200, মাছ 12000 (আলুর দর README-র; বাকি দুটি এই উদাহরণের জন্য বানানো). একই টেবিল একবার const দিয়ে, একবার ছাড়া, আমার lab-এর types.c-তে:

static const uint16_t rate_flash[3] = {6550, 4200, 12000};
static uint16_t       rate_ram[3]   = {6550, 4200, 12000};
    rate_ram[0] = 7000;                              /* ঠিক আছে */
    *(volatile uint16_t *)&rate_flash[0] = 7000;      /* cast দিয়ে const ভাঙা */
সত্যিকারের run — board.py run build/types.elf (অংশ)
[     0.2347 ms] UART: flash addr    = 0x08000522
[     0.2646 ms] UART: ram addr      = 0x20000006
[     0.2935 ms] UART: rate_ram[0]   = 7000
[     0.2943 ms] HardFault: Write to write-protected memory (UC_ERR_WRITE_PROT) at PC=0x08000174 main+0xF8
[     0.3274 ms] UART: HardFault_Handler: write to flash refused
[     0.3282 ms] exit(3) after 2626 cycles

build/types.map (অংশ)
 8000522  8000522        6     1                 rate_flash
20000006  800052e        6     1                 rate_ram

Map file-এর দুই সারি পুরো গল্প বলে। rate_flash বসেছে flash-এ, .rodata section-এ (0x08000522): ৬ byte flash, SRAM-এ শূন্য। rate_ram-এর দুটি ঠিকানা: চলার সময় থাকে SRAM-এ (0x20000006), কিন্তু তার শুরুর মানগুলো flash-এও রাখতে হয় (0x0800052E), যেখান থেকে startup কোড reset-এর পরে কপি করে। মানে const ছাড়া টেবিল দুই জায়গাতেই জায়গা খায়, আর boot-এর সময় কপির সময়ও নেয়। ২০ KiB SRAM-এর chip-এ একটি বড় font বা lookup table const না দিলে SRAM-এর বড় অংশ অকারণে খরচ হয়। Section আর linker script-এর পুরো ব্যাখ্যা পর্ব ৩১-এ (Memory map আর linker script).

আর cast দিয়ে const ভেঙে flash-এ লিখতে গেলে board-এ সত্যিই HardFault: Spec decision 18 অনুযায়ী board-এর flash-এ লেখা fault দেয়। আসল chip-এ flash-এ সাধারণ STR-এর ফল chip-ভেদে আলাদা: কোথাও bus fault, কোথাও চুপচাপ উপেক্ষা; flash লিখতে আলাদা controller-এর ধাপ লাগে। C-র দিক থেকে const বস্তু বদলানো undefined behavior, তাই compiler-ও ধরে নিতে পারে মান কখনো বদলায় না। আর সাধারণ পথে rate_flash[0] = 7000; লিখলে compile-ই হয় না, যা সবচেয়ে ভালো সুরক্ষা।

একটি সূক্ষ্মতা: const char *p মানে “p যেখানে দেখায়, সেটি বদলাব না”, pointer নিজে বদলাতে পারে, আর data flash-এ থাকবে এমন নিশ্চয়তা নেই। Data-কেই const করতে হয়: static const char banner[] = "...";. String literal ("waiting ...") নিজে থেকেই .rodata-তে যায়, এই পর্বের সব firmware-এর map-এ .rodata.str1.1 হিসেবে দেখা যায়।

৭ · Integer promotion-এর ফাঁদ — ৮ আর ১৬ বিটের হিসাব

C-তে int-এর চেয়ে ছোট কোনো টাইপ নিয়ে সরাসরি হিসাব হয় না। যোগ, বিয়োগ, তুলনা, ~ বা shift-এর আগে uint8_t, int16_t-এর মতো ছোট মান আগে int-এ তোলা হয়, যার নাম integer promotion. নিয়মটি এক লাইনে: ছোট টাইপের সব মান int-এ আঁটলে int, না আঁটলে unsigned int. এরপর দুই পাশে আলাদা টাইপ থাকলে একটি সাধারণ টাইপ বাছা হয় (usual arithmetic conversions). পূর্ণ নিয়ম C পর্ব ০৮-এ; এখানে register আর sensor-এর হিসাবে যেখানে এটি কামড়ায়।

Board-এ types.c চালিয়ে পাওয়া মানগুলো (a = 200, b = 100, x = 0x80, সব uint8_t; মানগুলো volatile থেকে পড়া, যাতে compiler আগেভাগে হিসাব করে না ফেলে):

সত্যিকারের run — board.py run build/types.elf (অংশ)
[     0.0227 ms] UART: sizeof(int)=4
[     0.0500 ms] UART: a+b as int    = 300
[     0.0739 ms] UART: sum8 (uint8_t)= 44
[     0.0961 ms] UART: (a+b > 255)   = 1
[     0.1259 ms] UART: ~x as int     = 0xFFFFFF7F
[     0.1476 ms] UART: (~x == 0x7F)  = 0
[     0.1736 ms] UART: (uint8_t)~x   = 127
[     0.2049 ms] UART: w*2 (uint32)  = 80000
প্রতিটি ধাপে মান
C-তে
বিট (hex)
টাইপ
দশমিক ফল
  1. দুটি ৮ বিটের মান। a = 200 = 0xC8, b = 100 = 0x64; দুটিই uint8_t-এ আরামে আঁটে (সর্বোচ্চ 255).
  2. Promotion. uint8_t-এর সব মান (0–255) int-এ আঁটে, তাই হিসাবের আগে দুটিই ৩২ বিটের int হয়ে যায়: 0x000000C8 আর 0x00000064. Cortex-M-এ register ৩২ বিটের, তাই এটি স্বাভাবিকও।
  3. যোগ int-এ। 200 + 100 = 300 = 0x12C. কোনো overflow নেই, কারণ হিসাব ৩২ বিটে। board-এ a+b as int = 300.
  4. তুলনাও int-এ। 300 > 255, তাই a + b > 255 সত্য (1). “দুটি byte যোগ করে byte-এর বাইরে গেল কি না” পরীক্ষা এভাবেই সহজে লেখা যায়।
  5. ছোট ঘরে রাখা মানে কাটা। uint8_t sum8 = a + b; নিচের ৮ বিট রাখে: 0x12C-এর 0x2C = 44 (300 − 256). C-তে unsigned-এ রূপান্তরের এই wraparound নিয়মসিদ্ধ, warning-ও সাধারণত আসে না।
  6. ~-এর ফাঁদ। x = 0x80 আগে int 0x00000080 হয়, তারপর ~ ৩২টি বিটই উল্টায়: 0xFFFFFF7F = −129. তাই ~x == 0x7F মিথ্যা (0), যদিও ৮ বিটে ভাবলে সত্য মনে হয়। সমাধান: (uint8_t)~x == 0x7F, board-এ 127.

একই নিয়ম এবার desktop-এর gcc-তে, Wandbox-এ চালিয়ে দেখুন। শেষ লাইনে smart scale-এর একটি পরিচিত ফাঁদ: gross int32_t কিন্তু tare ভুল করে uint32_t; মেশালে বিয়োগ হয় unsigned-এ।

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

int main(void)
{
    volatile uint8_t in_a = 200, in_b = 100, in_x = 0x80;  /* register-এর মতো */
    uint8_t a = in_a, b = in_b, x = in_x;
    uint8_t sum8 = a + b;
    printf("sizeof(int) = %zu\n", sizeof(int));
    printf("a + b       = %d\n", a + b);
    printf("sum8        = %u\n", (unsigned)sum8);
    printf("a + b > 255 = %d\n", a + b > 255);
    printf("~x          = 0x%X\n", (unsigned)~x);
    printf("(uint8_t)~x == 0x7F -> %d\n", (uint8_t)~x == 0x7F);
    uint16_t w = 40000;
    uint32_t big = w * 2;
    printf("w * 2       = %u\n", (unsigned)big);
    int32_t gross = 150;
    uint32_t tare = 1400;                     /* ভুল টাইপ */
    printf("gross - tare = %u\n", (unsigned)(gross - tare));
    return 0;
}

আসল আউটপুট (Wandbox, gcc):

sizeof(int) = 4
a + b       = 300
sum8        = 44
a + b > 255 = 1
~x          = 0xFFFFFF7F
(uint8_t)~x == 0x7F -> 1
w * 2       = 80000
gross - tare = 4294966046

প্রথম সাতটি লাইন board-এর Cortex-M3-এর সঙ্গে হুবহু মেলে, কারণ দুই জায়গাতেই int ৩২ বিট। শেষ লাইনটি tare-এর ফাঁদ: int32_t আর uint32_t একই মাপের, তাই usual arithmetic conversions-এ unsigned জেতে, আর 150 − 1400-এর −1250 হয়ে যায় 232 − 1250 = 4294966046. Scale-এর display-এ এটি “৪২৯ কোটি গ্রাম”! বাজারঘরের reference scale.c-তে তাই gross, tare, net সবই int32_t.

এবার সবচেয়ে বিপজ্জনক অংশ: একই কোড ৮ বিটের chip-এ। AVR-এ int ১৬ বিট (অংশ ২-এ Clang-এ দেখা), তাই promotion-এর ফলও বদলায়। নিচের ব্লক C-র নিয়মটি দুই মাপের int-এর জন্য পাশাপাশি হিসাব করে:

# C-এর integer promotion আর usual arithmetic conversion: int 16 বিট বনাম 32 বিট
def promote(bits, signed, int_bits):
    """int-এর চেয়ে ছোট টাইপ: int-এ সব মান আঁটলে int, নইলে unsigned int"""
    if bits > int_bits:
        return bits, signed                       # long ইত্যাদি: যেমন আছে
    fits = signed or bits < int_bits
    return int_bits, fits

def calc(op, a, ta, b, tb, int_bits):
    (wa, sa), (wb, sb) = promote(*ta, int_bits), promote(*tb, int_bits)
    w = max(wa, wb)
    s = (sa if wa > wb else sb if wb > wa else sa and sb)  # সমান চওড়া: unsigned জেতে
    exact = {"+": a + b, "-": a - b, "*": a * b}[op]
    if not s:
        return f"{exact % 2**w} (unsigned {w})"
    if -2**(w - 1) <= exact < 2**(w - 1):
        return f"{exact} (int {w})"
    return f"UB! {exact} int {w}-এ আঁটে না"

U8, U16, I = (8, False), (16, False), (16, True)
cases = [("200+100 (u8)", "+", 200, U8, 100, U8),
         ("200*200 (u8)", "*", 200, U8, 200, U8),
         ("40000*2 (u16)", "*", 40000, U16, 2, I),
         ("100-200 (u8)", "-", 100, U8, 200, U8),
         ("100-200 (u16)", "-", 100, U16, 200, U16),
         ("1250*6550 (int)", "*", 1250, I, 6550, I)]
print(f"{'expression':18} {'int = 16 bit (AVR)':28} int = 32 bit (Cortex-M)")
for name, op, a, ta, b, tb in cases:
    print(f"{name:18} {calc(op, a, ta, b, tb, 16):28} {calc(op, a, ta, b, tb, 32)}")

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

expression         int = 16 bit (AVR)           int = 32 bit (Cortex-M)
200+100 (u8)       300 (int 16)                 300 (int 32)
200*200 (u8)       UB! 40000 int 16-এ আঁটে না   40000 (int 32)
40000*2 (u16)      14464 (unsigned 16)          80000 (int 32)
100-200 (u8)       -100 (int 16)                -100 (int 32)
100-200 (u16)      65436 (unsigned 16)          -100 (int 32)
1250*6550 (int)    UB! 8187500 int 16-এ আঁটে না 8187500 (int 32)

তিনটি শিক্ষা। এক, দুটি uint8_t-এর গুণ AVR-এ signed int-এ হয়, আর 40000 ১৬ বিটের int-এ আঁটে না: undefined behavior, যদিও দুটি operand-ই unsigned! দুই, uint16_t AVR-এ unsigned int-এ ওঠে, তাই 40000 × 2 = 14464, ঠিক যা Clang-এর AVR assembly-তে দেখেছেন; Cortex-M-এ 80000. তিন, 100 - 200 uint8_t-এ দুই chip-এই −100, তাই if (a - b < 0) কাজ করে; কিন্তু uint16_t-এ AVR-এ 65436, আর একই if মিথ্যা। শেষ সারি বাজারঘরের দামের হিসাব: int-এ লিখলে AVR-এ 5 g-এর বেশি ওজনেই overflow (32767 ÷ 6550 ≈ 5), তাই সেখানে int32_t বাধ্যতামূলক।

৮ · MISRA-ধাঁচের অভ্যাস — bug আসার আগেই আটকানো

গাড়ি, চিকিৎসা-যন্ত্র আর শিল্পের firmware-এ এই ধরনের bug ঠেকাতে একটি নিয়মের সংকলন বহুল প্রচলিত: MISRA C. প্রথম সংস্করণ ১৯৯৮ সালে গাড়ি শিল্পের জন্য; পরে ২০০৪ আর ২০১২ সালের বড় সংস্করণ, তারপর আরও হালনাগাদ। এর একটি মূল ধারণা “essential type”: uint8_t-এর হিসাবকে আপনি যেমন ভাবছেন (৮ বিট, চিহ্নহীন), কোড যেন সেভাবেই চলে, আর promotion-এর লুকানো রূপান্তর যেন স্পষ্ট cast-এ লেখা থাকে। নিয়মগুলোর বিস্তারিত পর্ব ৬৩-এ (নির্ভরযোগ্যতা আর safety — MISRA C); এখানে এই পর্বের bug থেকে সরাসরি আসা কয়েকটি অভ্যাস:

শেষ অভ্যাসটি এই পর্বের সবচেয়ে বাস্তব শিক্ষা। Volatile-এর ভুল -O0-এ লুকিয়ে থাকে, তাই যে flag দিয়ে পণ্য বাজারে যাবে, পরীক্ষাও সেই flag দিয়েই। আর promotion-এর বহু ভুল -Wconversion ধরে ফেলে, যা -Wall -Wextra-এর অংশ নয়।

আরও গভীরে: ARMv7-M Architecture Reference Manual অনুযায়ী aligned word, halfword আর byte-এর একক LDR/STR “single-copy atomic”: অন্য কেউ অর্ধেক-লেখা মান দেখবে না। তাই Cortex-M3-এ একজন লেখক আর একজন পাঠকের ৩২ বিটের flag-এ volatile-ই যথেষ্ট, কিন্তু uint64_t বা packed struct-এর অসমান্তরাল field-এ নয়। আর volatile access-এর মাপ যে compiler রক্ষা করে, তা hardware-এর জন্য জরুরি: কিছু peripheral-এ ৩২ বিটের register byte-এ লিখলে অন্য তিন byte নষ্ট হয় বা bus fault ওঠে। C standard নিজে বলে, volatile বস্তুর “access” কী, তা implementation-defined; তাই চূড়ান্ত সত্য সবসময় compiler-এর output.

পরীক্ষা ও ইন্টারভিউতে: “volatile কেন লাগে?” → hardware register আর ISR-এর মতো compiler-এর অজান্তে বদলানো মেমরির প্রতিটি access রক্ষা করতে। “একটি variable কি const আর volatile দুটিই হতে পারে?” → হ্যাঁ, read-only status register. “volatile কি ISR-এর counter-কে নিরাপদ করে?” → না, ++ একটি read-modify-write, atomic নয়। “-O0-এ চলে, -O2-এ চলে না, প্রথম সন্দেহ?” → volatile ছাড়া ভাগ করা variable বা undefined behavior. “AVR-এ sizeof(int)?” → 2.

৯ · AI-এর যুগে embedded C যাচাই

AI assistant সাধারণ C ভালো লেখে, কিন্তু firmware-এর এই সূক্ষ্ম জায়গাগুলোতে প্রায়ই ভুল করে, আর ভুলটি compile হয়, এমনকি -O0-এ চলেও। কয়েকটি পরিচিত ভুল আর ধরার উপায়:

AI প্রায়ই যা করেকীভাবে ধরবেন
ISR-এর flag বা tick counter-এ volatile ভুলে যায়-O2 দিয়ে -S output দেখা: loop-এর ভেতরে ldr আছে কি না; board-এ release build চালানো
“volatile দিলে thread-safe/ISR-safe” বলে++-এর assembly-তে LDR/ADD/STR দেখা; এই পর্বের race.c-র মতো পরীক্ষা
ISR-এ printf, malloc বা দীর্ঘ অপেক্ষা ঢোকায়ISR-কে flag তোলা আর data কপিতে সীমিত রাখা (পর্ব ৪৩)
সব জায়গায় int, অথবা ৮ বিটের chip-এ ৩২ বিটের মতো হিসাবTarget-এর sizeof(int) জানা; সবচেয়ে বড় ইনপুটে সীমা হিসাব; -Wconversion
নির্দিষ্ট chip-এর register-এর ঠিকানা বা বিট বানিয়ে বলেChip-এর reference manual; এই কোর্সে bazarghar.h আর README
Interrupt বন্ধ না করে ভাগ করা word-এ |= বা ++Critical section, atomic, বা BSRR-ধাঁচের register (পর্ব ৩৫)

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

আমি ARM Cortex-M3-এর জন্য bare-metal C লিখছি (Clang, -O2, -ffreestanding, OS নেই)। ১. নিচের কোডে SysTick ISR আর main একটি flag ভাগ করে। কোন variable-এ volatile লাগবে আর কেন, এক লাইনে বলো। তারপর -O2-এ volatile ছাড়া compiler loop-টিকে কী করতে পারে, C11-এর কোন নিয়মে, তা ব্যাখ্যা করো। ২. main আর ISR দুজনেই একটি uint32_t counter-এ ++ করলে volatile কি যথেষ্ট? না হলে Cortex-M3-এ দুটি সমাধান দাও, আর Cortex-M0-এ কোনটি চলবে না বলো। ৩. uint8_t a = 200, b = 100 হলে a + b, (uint8_t)(a + b) আর ~a-এর মান int ৩২ বিট আর ১৬ বিট দুই ক্ষেত্রেই বলো। ৪. কোনো register-এর ঠিকানা বা cycle সংখ্যা দিলে উৎস বলবে; নিশ্চিত না হলে "নিশ্চিত নই" লিখবে।

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

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

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

প্র ০১volatile কেন C-তে এল, আর আজ thread-এর জগতে কেন একে “ভুল হাতিয়ার” বলা হয়?

C-র জন্ম ১৯৭০-এর দশকে, Unix লেখার জন্য, আর তখনকার compiler খুব কমই optimize করত: আপনি যা লিখতেন, প্রায় তা-ই machine code হতো। Device driver সরাসরি register-এর ঠিকানায় পড়ত-লিখত, আর তাতে সমস্যা হতো না। আশির দশকে compiler বুদ্ধিমান হলো: register-এ মান ধরে রাখা, অকাজের পড়া-লেখা বাদ দেওয়া, loop-এর বাইরে কাজ তোলা। তখনই driver-গুলো ভাঙতে শুরু করে, কারণ hardware register-এর পড়া-লেখা “অকাজের” নয়। ১৯৮৯ সালের ANSI C (C89) standard-এ volatile আর const যুক্ত হয়, যাতে programmer compiler-কে বলতে পারেন কোন মেমরি তার অনুমানের বাইরে। Standard-এর নিজের উদাহরণেও memory-mapped I/O, setjmp/longjmp আর asynchronous signal-এর কথা আসে।

অর্থাৎ volatile বানানো হয়েছিল “compiler, এই access বাদ দেওয়া চলবে না” বলার জন্য, “এই কাজ অবিভাজ্য হতে হবে” বলার জন্য নয়। বহু-thread আর বহু-core-এর যুগে মানুষ এটিকে thread-এর মধ্যে ভাগ করা data-য় ব্যবহার করতে শুরু করেন, আর সমস্যায় পড়েন: volatile ++-কে atomic করে না (এই পর্বে board-এ 2284টি যোগ হারিয়েছে), আর অন্য, volatile নয় এমন data-র ক্রম রক্ষা করে না। Linux kernel-এর documentation-এ “volatile considered harmful” নামে একটি লেখাই আছে, যা kernel কোডে volatile প্রায় নিষেধ করে, কারণ সেখানে lock আর barrier-এর API সঠিক কাজটি করে।

C11 তাই আলাদা হাতিয়ার আনে: _Atomic, <stdatomic.h> আর memory order. এগুলো একসঙ্গে অবিভাজ্যতা আর ক্রম দুটিই দেয়। Cortex-M3-এ atomic_fetch_add compiler LDREX/STREX দিয়ে বানায়। তবু microcontroller-এ volatile-এর জায়গা হারায়নি: hardware register-এর জন্য এটিই সঠিক হাতিয়ার, আর একক-core-এ একজন লেখক ও একজন পাঠকের ছোট flag-এ এটিই যথেষ্ট। গোলমাল হয় তখন, যখন একটি হাতিয়ার দিয়ে দুটি আলাদা সমস্যা সমাধানের চেষ্টা হয়।

মূল উপলব্ধি: volatile hardware-এর জন্য বানানো “access বাদ দেওয়া চলবে না” নির্দেশ; একসঙ্গে চলা কোডের অবিভাজ্যতা আর ক্রমের জন্য দরকার atomic, critical section বা barrier.

প্র ০২Clang একটি অপেক্ষার loop পুরো মুছে দিল। একটি compiler-এর কি এমন অধিকার থাকা উচিত? এই নিয়ম থেকে firmware লেখক কী শেখেন?

প্রথম দেখায় এটি compiler-এর বাড়াবাড়ি মনে হয়: আমি অপেক্ষা করতে বলেছি, সে অপেক্ষাই বাদ দিল! কিন্তু নিয়মটির পেছনে যুক্তি আছে। C11-এর §6.8.5 অনুচ্ছেদ ৬ বলে, যে loop-এর শর্ত ধ্রুবক নয় আর ভেতরে কোনো I/O, volatile access, atomic বা synchronization নেই, implementation সেটিকে “শেষ হবে” বলে ধরে নিতে পারে। এই অনুমান না থাকলে compiler বহু সাধারণ loop নিয়ে কিছু করতে পারত না: একটি linked list হাঁটার loop-এর ফল ব্যবহার না হলেও সেটি মোছা যেত না, কারণ list যদি বৃত্তাকার হয়, loop কখনো শেষ হবে না, আর সেই “আচরণ” রক্ষা করতে হতো। নিয়মটি optimizer-কে বলে: যে loop বাইরের জগতে কিছুই করে না, তার একমাত্র কাজ শেষ হওয়া।

আমাদের loop A ঠিক এই শ্রেণির: while (!sample_due) { }-এর ভেতরে কিছু নেই, আর sample_due volatile নয়। Optimizer-এর চোখে loop-এর একমাত্র “দৃশ্যমান” আচরণ শেষ হওয়া, আর flag-এর মান বদলানোর কোনো উপায় সে দেখে না; শেষ হওয়ার একমাত্র উপায় flag আগে থেকেই 1, তাই loop বাদ। Loop B-এর শর্ত for (;;), একটি ধ্রুবক; standard সেখানে এই অনুমান দেয় না, তাই compiler চিরকালের loop রেখেছে। দুটি ফলই C-র নিয়মে বৈধ, কারণ আসল ভুল আগেই হয়েছে: একটি variable দুই পক্ষ সুরক্ষা ছাড়া ব্যবহার করছে, যা একটি data race. সব compiler একই আচরণ করে না; এই পর্বের ফল Clang 22.1.8-এর, আর অন্য compiler বা version অন্যভাবে ভাঙতে পারে।

Firmware লেখকের শিক্ষা তিনটি। এক, অপেক্ষার loop-এর শর্তে অন্তত একটি volatile access থাকতে হবে (flag, register), নইলে loop-এর ভাগ্য compiler-এর হাতে। দুই, “আমার compiler এখন এটা করে না” নির্ভরযোগ্য যুক্তি নয়; optimizer প্রতিটি version-এ আরও চতুর হয়। তিন, ইচ্ছাকৃত অসীম loop (যেমন main-এর শেষে for (;;) { } বা fault handler-এর থেমে থাকা) ধ্রুবক শর্তে লিখলে নিরাপদ, আর আরও ভালো হলো ভেতরে __WFI() বা watchdog-এর মতো কোনো দৃশ্যমান কাজ রাখা।

মূল উপলব্ধি: Optimizer C-র নিয়মে যা প্রমাণ করতে পারে, তাই করে; firmware-এ হার্ডওয়্যার বা ISR-এর কথা তাকে জানানোর একমাত্র ভাষা volatile আর atomic.

প্র ০৩Cold room-এর ১০টি reading একটি সাধারণ buffer-এ লিখে শেষে একটি volatile ready flag তোলা হলো। কোড review-তে কেউ বললেন, “flag volatile, তাই ঠিক আছে।” তিনি কোথায় ভুল, আর সঠিক নকশা কী?

ভুলটি volatile-এর প্রতিশ্রুতির সীমায়। C-র নিয়মে volatile access-গুলো একে অপরের সাপেক্ষে ক্রম রক্ষা করে, আর প্রত্যেকটি সত্যিই ঘটে। কিন্তু volatile নয় এমন access, যেমন buffer-এ লেখা, compiler চাইলে volatile লেখার আগে-পরে সরাতে পারে, কারণ তার চোখে buffer আর flag-এর মধ্যে কোনো সম্পর্ক নেই। ধরুন main-এর কোড: দশটি reading লেখা, তারপর ready = 1. Optimizer শেষ reading-এর লেখা ready = 1-এর পরে নিতে পারে, বা register-এ ধরে রেখে পরে লিখতে পারে। ঠিক সেই ফাঁকে ISR flag দেখে buffer পাঠায়, আর telemetry-তে যায় পুরোনো একটি তাপমাত্রা। বাজারঘরের cold room-এ এর মানে, dashboard-এ “7.00 °C” দেখাচ্ছে, অথচ আসল reading 9.00. বাস্তবে Clang হয়তো এখানে ক্রম বদলাবে না, কিন্তু standard সেই নিশ্চয়তা দেয় না।

সমাধান কয়েক স্তরের। সবচেয়ে সরল, buffer-কেও volatile করা; তাতে সব access-এর ক্রম রক্ষা হয়, কিন্তু buffer-এর প্রতিটি ব্যবহারে optimization বন্ধ হয়। ভালো সমাধান একটি compiler barrier: flag তোলার ঠিক আগে __asm volatile ("" ::: "memory"), যা কোনো নির্দেশ বানায় না কিন্তু compiler-কে বলে, মেমরির সব কাজ এখানেই শেষ করতে হবে। CMSIS-এর __DMB() একসঙ্গে compiler barrier আর CPU-র DMB নির্দেশ দেয়। Cortex-M3-এর মতো সরল একক-core-এ CPU সাধারণত নিজের লেখার ক্রম বদলায় না, তাই compiler barrier-ই মূল কাজ করে; Cortex-M7-এর write buffer আর cache থাকলে, বা DMA বা অন্য core data পড়লে, CPU-র barrier-ও লাগে। সবচেয়ে পরিষ্কার আধুনিক পথ C11-এর atomic_store_explicit(&ready, 1, memory_order_release), যা ঠিক এই “আগের সব লেখা আগে” অর্থ বহন করে।

নকশার দিক থেকেও ভাবা যায়: flag-এর বদলে একটি ring buffer, যেখানে লেখক শুধু head বদলায় আর পাঠক শুধু tail, আর প্রতিটি index-এর আগে barrier. এর data structure-এর দিকটি DSA কোর্সে, আর UART-এর সঙ্গে বাস্তব রূপ পর্ব ৪৯-এ। মনে রাখার মতো ব্যাপার হলো, এমন bug প্রায় কখনো বেঞ্চে ধরা পড়ে না; নির্দিষ্ট সময়ে interrupt এলে, বছরে হয়তো কয়েকবার।

মূল উপলব্ধি: volatile শুধু volatile access-এর ক্রম রাখে; “data আগে, flag পরে” নিশ্চিত করতে compiler barrier, CPU barrier বা release-ধাঁচের atomic লাগে।

প্র ০৪C কেন int-এর মাপ বেঁধে দেয়নি? এই স্বাধীনতার লাভ আর এমবেডেড কাজে তার দাম কী?

C-র নকশার মূল ভাবনা ছিল: int হবে সেই মাপ, যা ওই machine-এ সবচেয়ে স্বাভাবিক আর দ্রুত। ১৯৭০-এর দশকের PDP-11-এ সেটি ছিল ১৬ বিট, পরে বহু machine-এ ৩২ বিট। এই স্বাধীনতার কারণে একই C কোড ছোট আর বড় দুই রকম machine-এ দক্ষভাবে চলেছে, আর C ছড়িয়েছে প্রায় সব CPU-তে। Standard শুধু ন্যূনতম সীমা দেয়: int অন্তত −32767 থেকে 32767 ধরবে। এমবেডেড জগতে এর ফল চোখে পড়ার মতো: 8086-এর যুগের compiler-এ int ১৬ বিট ছিল, avr-gcc-তে আর এই পর্বে দেখা Clang-এর AVR target-এ এখনো ১৬ বিট, আর ARM Cortex-M, RISC-V বা ESP32-এ ৩২ বিট।

দাম দেখা যায় যখন কোড এক chip থেকে আরেক chip-এ যায়। বাজারঘরের দামের সূত্র net_g * 6550 Cortex-M-এ নিরাপদ, কিন্তু কেউ যদি প্রথমে Arduino-তে prototype বানাতে গিয়ে int ব্যবহার করেন, তাহলে 5 g-এর বেশি যেকোনো ওজনে signed overflow, অর্থাৎ undefined behavior. উল্টো দিকেও সমস্যা: ৩২ বিটের chip-এ লেখা “চলে যাওয়া” কোড ৮ বিটে আনলে promotion-এর ফল বদলায় (এই পর্বের Python ব্লকে uint16_t-এর 40000 × 2 = 14464 বনাম 80000). Protocol-এর struct, register-এর মাপ আর file format-এ এর ফল আরও গুরুতর, কারণ সেখানে প্রতিটি বিটের জায়গা বাঁধা।

১৯৯৯ সালের C99 তাই <stdint.h> আনে: int8_t থেকে uint64_t, যাদের মাপ নামেই লেখা (যে chip-এ সেই মাপ আছে, সেখানে)। তার আগে প্রতিটি কোম্পানি নিজের typedef বানাত (U8, UINT16, BYTE), আর দুই library মেলাতে গেলে নামের যুদ্ধ লাগত। MISRA C-ও এ কারণে মাপ আর চিহ্ন বোঝায় এমন typedef ব্যবহারের পরামর্শ দেয়। তবে stdint সব সমস্যা মেটায় না: promotion-এর নিয়ম তখনো int-এর মাপের ওপর নির্ভর করে। তাই uint16_t লিখলেও AVR আর Cortex-M-এ হিসাব আলাদা হতে পারে; গুণের আগে স্পষ্ট cast ((uint32_t)w * 2) সেই অনিশ্চয়তা দূর করে।

মূল উপলব্ধি: int-এর নমনীয় মাপ C-কে সব CPU-তে ছড়িয়েছে, কিন্তু firmware-এ মাপ অনুমানের ওপর ছাড়া যায় না; stdint-এর টাইপ আর স্পষ্ট cast দুটিই লাগে।

প্র ০৫MISRA-র মতো কড়া নিয়ম firmware-কে নিরাপদ করে, নাকি শুধু কাজ ধীর করে? একটি ছোট বাজারঘর-ধাঁচের দোকানের যন্ত্রে কতটা মানা উচিত?

MISRA C-র জন্ম ১৯৯০-এর দশকে, যুক্তরাজ্যের গাড়ি শিল্পের একটি প্রকল্প থেকে; প্রথম নির্দেশিকা প্রকাশ পায় ১৯৯৮ সালে। তখন গাড়িতে microcontroller বাড়ছিল, আর C-র নমনীয়তা (implicit রূপান্তর, undefined behavior, ইচ্ছামতো pointer) নিরাপত্তা-জরুরি যন্ত্রে ঝুঁকি হয়ে দাঁড়াচ্ছিল। MISRA-র কৌশল ভাষার একটি “নিরাপদ উপসেট” বেঁধে দেওয়া: কিছু জিনিস নিষেধ (যেমন সাধারণভাবে dynamic memory), কিছু সীমিত, আর বহু নিয়ম এমনভাবে লেখা যাতে static analysis tool যন্ত্রের মতো যাচাই করতে পারে। এই পর্বের বেশিরভাগ bug, যেমন signed-unsigned মেশানো, ছোট টাইপের ~-এর ফল, নীরব কাটা, MISRA-র essential type-এর নিয়মে ধরা পড়ার কথা।

দামও আছে। কোড লম্বা হয় (স্পষ্ট cast-এর ছড়াছড়ি), কিছু নিয়ম অভিজ্ঞ লেখকের কাছে অকারণ মনে হয়, আর পুরোপুরি মানতে tool, প্রশিক্ষণ আর “deviation”-এর নথি লাগে। গাড়ি বা চিকিৎসা-যন্ত্রে এই দাম ন্যায্য, কারণ ভুলের ফল মানুষের প্রাণ। বাজারঘরের smart scale-এর ভুলে প্রাণ যায় না, কিন্তু টাকা আর আস্থা যায়: ১৫০ g-এর tare ভুল টাইপে রাখলে দাম হতে পারে কোটি টাকা, আর cold room-এর alarm volatile-এর ভুলে না বাজলে এক রাতে পুরো গুদামের মাছ নষ্ট।

বাস্তবসম্মত পথ মাঝামাঝি: পুরো MISRA সনদ নয়, কিন্তু তার মূল অভ্যাসগুলো। মাপসহ টাইপ, signed-unsigned না মেশানো, ISR-এর ভাগ করা data-র নিয়ম, heap এড়ানো, -Wall -Wextra -Wconversion-এ শূন্য warning, আর release flag-এ পরীক্ষা। এর সঙ্গে একটি ছোট static analyzer, যেমন Clang-এর নিজের analyzer বা cppcheck, অনেক ঝুঁকি কমায়। নিয়মের পুরো তালিকা, functional safety-র standard আর কখন সনদ লাগে, তা পর্ব ৬৩-এ। মূল কথা হলো, MISRA-র নিয়মগুলো আকাশ থেকে পড়েনি; প্রায় প্রতিটির পেছনে এই পর্বের মতো একটি বাস্তব bug আছে।

মূল উপলব্ধি: কড়া নিয়ম ঝুঁকির মাপে বেছে নিতে হয়; পুরো MISRA নিরাপত্তা-জরুরি যন্ত্রের জন্য, কিন্তু তার মূল অভ্যাসগুলো যেকোনো firmware-কে সস্তায় অনেক নিরাপদ করে।

অনুশীলন

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

  1. নকশা ও বাস্তবায়ন — wrap-safe delay: SysTick-এর 1 ms ISR দিয়ে একটি uint32_t tick counter আর delay_ms(uint32_t ms) লিখুন, যা counter 0xFFFFFFFF পেরিয়ে 0-তে ফিরলেও (প্রায় ৪৯.৭ দিন পরে) ঠিক কাজ করে। কোন variable-এ volatile, কেন Cortex-M3-এ পড়ার সময় interrupt বন্ধ লাগে না, আর AVR-এ কেন লাগবে?
    static volatile uint32_t ms_ticks;          /* ISR লেখে, main পড়ে */
    void SysTick_Handler(void) { ms_ticks++; }   /* একমাত্র লেখক */
    static uint32_t ticks_get(void) { return ms_ticks; }  /* একটি LDR */
    static void delay_ms(uint32_t ms)
    {
        uint32_t start = ticks_get();
        while ((uint32_t)(ticks_get() - start) < ms)
            __WFI();                             /* পরের tick পর্যন্ত ঘুম */
    }

    মূল কৌশল unsigned বিয়োগ: now - start ৩২ বিটে wraparound করে, তাই wrap-এর পরেও পেরোনো সময় ঠিক আসে। আমার lab-এর delay.c-তে counter ইচ্ছা করে 0xFFFFFF00 থেকে শুরু করে board-এ চালানো হলো: ticks=0xFFFFFFFA (250.0263 ms), ticks=0x000000F4 (500.0263 ms), ticks=0x000001EE (750.0263 ms); wrap-এর মধ্য দিয়েও ঠিক 250 tick পরপর। ms_ticks volatile, কারণ ISR বদলায় আর loop বারবার পড়ে। Cortex-M3-এ লেখক একজনই (ISR), আর aligned ৩২ বিটের পড়া একটি LDR, যা অবিভাজ্য; তাই পড়ার সময় interrupt বন্ধ লাগে না। AVR-এ একই পড়া চারটি byte-এর চারটি নির্দেশ; মাঝে ISR counter বদলালে (যেমন 0x00FF থেকে 0x0100) অর্ধেক পুরোনো, অর্ধেক নতুন মান আসতে পারে, তাই সেখানে পড়ার সময় interrupt বন্ধ রাখতে হয়।

  2. ভুল খুঁজুন — scale-এর tare বোতাম: নিচের Cortex-M3 firmware-এ তিনটি ভুল আছে। খুঁজুন আর প্রতিটির ফল বলুন।
    uint8_t tare_flag;                       /* EXTI0 ISR এটি 1 করে */
    const uint16_t rates[2] = {6550, 4200};
    uint8_t mask = 0x0F;
    ...
    while (tare_flag == 0) { }               /* বোতামের অপেক্ষা */
    if (~mask == 0xF0) do_tare();
    rates[0] = 7000;                         /* দর বদল */

    (১) tare_flag volatile নয়: -O2-এ loop মুছে যেতে পারে (অপেক্ষা ছাড়াই এগোনো) বা একবার পড়ে আটকে যেতে পারে। এই পর্বের board run-এ ঠিক এই দুই আচরণ দেখা গেছে (loop A আর B). সমাধান: static volatile uint8_t tare_flag;. (২) ~mask হয় int-এ: 0x0000000F থেকে 0xFFFFFFF0, যা 0xF0 নয়, তাই do_tare() কখনো চলবে না। Board-এ একই নিয়মের run: ~x (x = 0x80) = 0xFFFFFF7F আর ~x == 0x7F = 0. সমাধান: (uint8_t)~mask == 0xF0. (৩) rates const, তাই rates[0] = 7000; compile-ই হবে না (const বস্তুতে লেখা একটি constraint লঙ্ঘন)। দর বদলানোর দরকার হলে টেবিল SRAM-এ (const ছাড়া) রাখতে হবে, বা flash-এ লেখার আলাদা নিয়ম মানতে হবে; cast দিয়ে জোর করে লিখলে board-এ HardFault হয়েছে।

  3. আগে বলুন, তারপর মিলিয়ে দেখুন — দুই chip, এক কোড: uint16_t w = 40000; uint32_t r = w * 2; আর uint8_t a = 100, b = 200; int neg = (a - b < 0);. AVR (int ১৬ বিট) আর Cortex-M3 (int ৩২ বিট)-এ r আর neg কত? a, b uint16_t হলে neg কী হয়?

    Cortex-M3: w → int (৩২ বিট), 40000 × 2 = 80000, তাই r = 80000 (board-এ w*2 (uint32) = 80000). AVR: uint16_t-এর সব মান ১৬ বিটের int-এ আঁটে না, তাই unsigned int (১৬ বিট); 80000 mod 65536 = 14464, তারপর uint32_t-এ রাখা: r = 14464. Clang-এর AVR assembly-তে ওপরের দুই byte সোজা 0 বসানো (ldi r24, 0) ঠিক এটাই দেখায়। uint8_t-এর 100 − 200 দুই chip-এই int-এ −100, তাই neg = 1. uint16_t হলে Cortex-M3-এ এখনো int, −100, neg = 1; কিন্তু AVR-এ unsigned int-এ 65436, neg = 0. সবগুলো এই পর্বের promo16.py-র টেবিলের সঙ্গে মেলে।

  4. হিসাব — কতগুলো যোগ হারাবে: main একটি volatile counter-এ ১,০০,০০০ বার LDR, ADD, STR করে, আর SysTick ISR মোট 3440 বার চলে, প্রতিবার একই counter-এ +1. ISR main-এর তিনটি নির্দেশের আগে সমান সম্ভাবনায় আসে ধরে নিলে কতগুলো যোগ হারানোর কথা? শেষে counter-এর মান মোটামুটি কত? Board-এর আসল ফলের সঙ্গে মেলান।

    ISR তিনটি জায়গায় আসতে পারে: LDR-এর আগে (main পরে নতুন মান পড়বে, ক্ষতি নেই), ADD-এর আগে বা STR-এর আগে (main-এর হাতে পুরোনো কপি, ISR-এর যোগ মুছে যাবে)। তাই ক্ষতির সম্ভাবনা ২/৩. প্রত্যাশিত ক্ষতি ≈ 3440 × ২/৩ ≈ 2293. সঠিক মোট = 100000 + 3440 = 103440, তাই counter ≈ 103440 − 2293 ≈ 101147. Board-এর সত্যিকারের run: shared=101156 expected=103440 lost=2284, অর্থাৎ হার 2284 ÷ 3440 = 0.664, হিসাবের 0.667-এর খুব কাছে। cpsid/cpsie দিয়ে ঘিরলে ক্ষতি 0.

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

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

ক্রমএকক-core Cortex-M-এ একটি ISR প্রতি tick-এ একটি volatile counter বাড়ায়। main সেই counter-এর জমা মান নিয়ে শূন্য করে UART-এ পাঠাতে চায়। নিরাপদ ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. ISR প্রতি tick-এ volatile counter বাড়ায়
  2. main __disable_irq() দিয়ে interrupt বন্ধ করে
  3. main counter-এর কপি একটি local variable-এ নেয় আর counter শূন্য করে
  4. main __enable_irq() দিয়ে interrupt আবার চালু করে
  5. main কপিটি দিয়ে ধীর কাজ করে (UART-এ পাঠানো)

একটি Cortex-M firmware-এ static uint32_t done; (volatile নয়) একটি ISR 1 করে, আর main লেখে while (!done) { }. -O2-এ compiler কী করতে পারে?

  • প্রতিবার মেমরি থেকে done পড়বে, কারণ এটি global
  • Compile error দেবে, কারণ ISR-এর সঙ্গে ভাগ করা variable volatile নয়
  • একবার পড়ে চিরকাল আটকে থাকা, বা loop পুরো বাদ দেওয়া
  • Loop-এর চারপাশে নিজে থেকে interrupt বন্ধ করবে

একক-core Cortex-M3-এ main আর একটি ISR দুজনেই static volatile uint32_t count;-এ count++ করে। কোন কথাটি ঠিক?

  • volatile থাকায় কোনো যোগ হারাবে না
  • যোগ হারাতে পারে; main-এর ++ critical section বা atomic দিয়ে রক্ষা করতে হবে
  • ISR-এর ভেতরের ++-এ interrupt বন্ধ করলেই যথেষ্ট
  • volatile সরিয়ে দিলেই সমস্যা মিটবে

৩২ বিটের int-এর একটি microcontroller-এ uint8_t x = 0x80;. ~x == 0x7F-এর মান কী, আর কেন?

  • 1, কারণ ~0x80 = 0x7F
  • Compile error, কারণ uint8_t-এ ~ চলে না
  • Undefined behavior
  • 0, কারণ ~x হয় int-এ 0xFFFFFF7F

একটি Cortex-M firmware-এ static const uint16_t table[64] = {...}; লেখা। এই টেবিল সাধারণত কোথায় থাকে, আর লাভ কী?

  • Flash-এর .rodata-তে; SRAM বাঁচে, startup-এ কপি লাগে না
  • SRAM-এর .data-তে, flash থেকে কপি হয়ে
  • Stack-এ, প্রতিবার function ডাকলে বানানো হয়
  • Heap-এ, malloc দিয়ে

AVR ATmega328P-এ (int ১৬ বিট) uint16_t w = 40000; uint32_t r = w * 2;-এর পরে r কত?

  • 80000
  • Undefined behavior, কারণ signed int-এ overflow
  • 14464
  • 40000, কারণ গুণ হয়ই না

C-তে volatile সম্পর্কে কোন কথাটি সঠিক?

  • volatile একটি memory barrier, তাই এর আগের সব লেখা আগে শেষ হয়
  • প্রতিটি volatile পড়া-লেখা সত্যিই ঘটবে, আর volatile access-গুলোর ক্রম বদলাবে না
  • volatile দিলে count++ atomic হয়
  • একটি variable একসঙ্গে const আর volatile হতে পারে না

শব্দকোষ

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

মনে রাখুন

  1. Freestanding: firmware-এ OS নেই, heap এড়ানো হয়, আর hardware ও ISR আপনার কোডের অজান্তে মেমরি বদলায়; compiler তা জানে না।
  2. volatile করে: প্রতিটি পড়া-লেখা সত্যিই, লেখা মাপে, volatile-দের নিজেদের ক্রমে। Register আর ISR-এর flag-এ বাধ্যতামূলক; না দিলে -O2-এ loop মুছে যেতে বা চিরকাল আটকে যেতে পারে।
  3. volatile করে না: atomic নয় (++ = LDR, ADD, STR), barrier নয়; ভাগ করা লেখায় critical section বা atomic, data-র ক্রমে barrier.
  4. stdint আর promotion: মাপসহ টাইপ ব্যবহার; ছোট টাইপ হিসাবের আগে int-এ ওঠে, আর int-এর মাপ chip-ভেদে ১৬ বা ৩২ বিট; ~, বিয়োগ আর গুণে সাবধান।
  5. const: টেবিল flash-এর .rodata-তে, SRAM বাঁচে; release flag-এ পরীক্ষা আর -Wconversion অনেক bug আগেই ধরে।

পরের পর্বে: পর্ব ৩৫ (Register-এর bit manipulation — set, clear, toggle আর bit field). Mask দিয়ে বিট বসানো আর মোছা, read-modify-write-এর সময় interrupt এলে হারানো বদল, আর BSRR-ধাঁচের register দিয়ে তার atomic সমাধান, বাজারঘর board-এর GPIO-তে সত্যিকারের run-এ।

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

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