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

Boot আর startup code — reset vector থেকে main পর্যন্ত

Boot and Startup Code — the Cortex-M Reset Sequence, Reset_Handler Line by Line, .data and .bss, Returning from main, Bootloaders and VTOR

Taught in Bangla, this lesson follows a Cortex-M reset from the first two vector-table words to main(). It reads a reference Reset_Handler line by line and in Clang's assembly, traces the boot on the course's virtual BG-M3 board (bl main at the 39th instruction), and shows a skipped .bss clear keeping an old tare after a software reset (81.88 Tk instead of 91.70). It covers returning from main and the 0xFFFFFFFF LR, then runs a small bootloader that validates an application's vector table, sets VTOR and jumps.

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

  • Reset-এর পরে Cortex-M ঠিক কোন ঠিকানা থেকে কী পড়ে, আর 8085/8086-এর সঙ্গে এর পার্থক্য
  • Reference lab-এর startup.c লাইন ধরে পড়া, আর তার আসল Thumb assembly বোঝা
  • .data কপি আর .bss শূন্য না হলে কী ভাঙে, আর main() ফিরলে কী হয়
  • C কোড চালানোর আগে কোন কোন অনুমান সত্য করতে হয় (C runtime-এর অনুমান)
  • ROM bootloader, নিজের bootloader আর VTOR দিয়ে application-এ লাফ দেওয়ার নিয়ম

১ · বিদ্যুৎ আসার পরের প্রথম মুহূর্ত

সকালে বাজারঘরের দোকান খোলার একটি নির্দিষ্ট রুটিন আছে। শাটার তোলা, বাতি জ্বালানো, দাঁড়িপাল্লা শূন্যে আনা, গতকালের খাতার পাতা উল্টে আজকের দামের তালিকা টাঙানো, তারপর প্রথম ক্রেতা। কেউ এই রুটিন বাদ দিলে দিনের শুরুতেই ভুল ওজন আর ভুল দাম। একটি microcontroller-এর জীবনেও প্রতিবার চালু হওয়ার পরে ঠিক এমন একটি রুটিন চলে। একে বলে boot, আর যে ছোট কোড রুটিনটি চালায় তাকে বলে startup code. আপনার main() শুরু হওয়ার আগেই এটি কাজ শেষ করে।

এই পর্বে ঠিকানা আর সংখ্যা C ধাঁচের hexadecimal-এ লেখা হবে (0x08000000), যেমন পুরো মডিউল ৫-এ; মডিউল ২–৪-এর Intel রীতির FFFF0H-এর সঙ্গে পার্থক্য শুধু লেখায়।

পুরোনো CPU: একটি নির্দিষ্ট ঠিকানা

আগের মডিউলে দেখেছেন, reset-এর পরে 8085-এর program counter 0000H হয়, আর 8086 শুরু করে physical address FFFF0H থেকে (CS = FFFFH, IP = 0000H; পর্ব ১৪)। এই নির্দিষ্ট ঠিকানাকে বলে reset vector, আর সেখানে স্থায়ী মেমরি রাখতেই হয় (পর্ব ২২)। সেখানে থাকে একটি instruction, সাধারণত একটি jump. Stack pointer কোথায় হবে, তা ঠিক করার দায়িত্ব প্রোগ্রামের প্রথম কয়েকটি assembly instruction-এর।

Cortex-M: একটি ঠিকানা নয়, একটি টেবিল

Cortex-M অন্যভাবে শুরু করে। ARMv7-M Architecture Reference Manual অনুযায়ী reset-এর পরে processor vector table-এর প্রথম দুটি word পড়ে:

  1. Offset 0x00-এর word যায় MSP-তে (main stack pointer; register-গুলোর পরিচয় পর্ব ২৯-এ)। তাই প্রথম instruction চলার আগেই stack তৈরি।
  2. Offset 0x04-এর word হলো reset handler-এর ঠিকানা। তার bit 0 যায় EPSR-এর T bit-এ, বাকিটা PC-তে। Cortex-M শুধু Thumb চালায়, তাই এই bit 1 হতেই হবে; 0 হলে প্রথম instruction-এই fault হয়।
  3. LR পায় 0xFFFFFFFF, একটি ইচ্ছাকৃত অবৈধ ফেরার ঠিকানা। ষষ্ঠ অংশে দেখবেন, কেন।
বিষয়80858086Cortex-M (BG-M3)
প্রথম instruction কোথা থেকে0000HFFFF0H (CS = FFFFH, IP = 0000H)টেবিলের word 1-এ লেখা ঠিকানা (0x08000358)
Stack pointerপ্রোগ্রাম নিজে বসায় (LXI SP)প্রোগ্রাম নিজে বসায় (SS, SP)Hardware বসায়: টেবিলের word 0 (0x20005000)
সেখানে কী থাকেএকটি instructionএকটি instruction (সাধারণত far jump)একটি ঠিকানা, instruction নয়
প্রথম কোড কোন ভাষায়AssemblyAssemblyসাধারণ C সম্ভব

Vector table কোথায় আছে, তা বলে SCB-এর VTOR register (0xE000ED08). Cortex-M3-এর Technical Reference Manual অনুযায়ী এর reset মান 0, অর্থাৎ টেবিল ঠিকানা 0x00000000-এ। তাহলে flash 0x08000000-এ থাকলে কাজ চলে কীভাবে? STM32F103-এর মতো chip-এ reset-এর সময় BOOT pin-এর অবস্থা দেখে বাছাই করা মেমরিকে ঠিকানা 0-তে “alias” করা হয়, মানে একই মেমরি দুই ঠিকানায় দেখা যায় (ST-এর RM0008). কোর্সের virtual “বাজারঘর board” BG-M3 এই খুঁটিনাটি সরল করেছে: সেখানে reset-এ VTOR = 0x08000000, MSP আসে 0x08000000 থেকে আর PC 0x08000004 থেকে; R0–R12 = 0, LR = 0xFFFFFFFF (Spec decision 18). BG-M3 আসল কোনো পণ্য নয়, আসল Cortex-M3-এর আদলে বানানো শিক্ষার মডেল (Spec decision 17).

উপমা — দোকানের চাবির খাম: দোকানের কর্মচারী সকালে এসে কাউন্টারের নিচের একটি নির্দিষ্ট খাম খোলেন। খামের প্রথম কাগজে লেখা “হিসাবের খাতা রাখবেন তাকের সবচেয়ে ওপরে” (stack কোথায়), দ্বিতীয় কাগজে “প্রথমে মালিকের রুটিনের তালিকা খুলবেন” (কোন কোড আগে)। খামটি কোথায় রাখা, তা মালিক চাইলে বদলাতে পারেন (VTOR). 8085 এমন কর্মচারী, যাঁকে শুধু বলা আছে “দরজা দিয়ে ঢুকে প্রথম টেবিলে যাবেন”; খাতা কোথায় রাখবেন, তা সেই টেবিলের চিরকুট পড়ে জানতে হয়।

ছবি ৩২.১ — Reset থেকে main: flash আর SRAM-এ কী কোথায়

ঠিকানাগুলো boot_demo.elf-এর আসল build থেকে (Clang 22.1.8, reference linker script)

Reset থেকে main: flash আর SRAM-এর মানচিত্র Flash (0x08000000, শুধু পড়া) vector table [0] 0x20005000 → MSP [1] 0x08000359 → PC [2..23] handler-এর ঠিকানা .text (code) main 0x08000060 Reset_Handler 0x08000358 .data-র প্রাথমিক মান _sidata 0x08000A08 6550, 5000 CPU ① MSP② PC SRAM (0x20000000, 20 KiB) stack ↓ (0x20005000 থেকে) main-এ SP = 0x20004FD8 .noinit 0x2000001C boot_no: ছোঁয়া হয় না .bss 0x20000008–1B samples[4], tare_g = 0 .data 0x20000000–07 rate_paisa, capacity_g ③ কপি ④ শূন্য ⑤ bl main → main 0x08000060

ছবির পাঁচটি ধাপই এই পর্বের মেরুদণ্ড। প্রথম দুটি hardware নিজে করে, বাকি তিনটি করে startup code. মেমরির অংশ (section), linker script আর map file-এর পুরো গল্প পর্ব ৩১-এ (Memory map আর linker script); এখানে শুধু startup code যা ছোঁয়, তা নিয়ে কথা।

২ · Vector table — reference lab-এর startup.c-এর প্রথম অর্ধেক

Reference lab-এর firmware/startup.c মাত্র ৮৩ লাইনের। প্রথম অর্ধেক vector table বানায়। নিচে তার মূল অংশ, হুবহু (মন্তব্য সংক্ষেপ করা):

extern uint32_t _sidata, _sdata, _edata, _sbss, _ebss, _estack;
int main(void);
void Reset_Handler(void);
void Default_Handler(void);

#define WEAK __attribute__((weak, alias("Default_Handler")))
void HardFault_Handler(void) WEAK;
void SysTick_Handler(void) WEAK;
void EXTI0_IRQHandler(void) WEAK;     /* ... আরও কয়েকটি */

typedef void (*vector_t)(void);

/* 16 system entries + 8 external IRQ slots */
__attribute__((section(".isr_vector"), used))
const vector_t g_vectors[16 + 8] = {
    (vector_t)&_estack,     /*  0 initial MSP */
    Reset_Handler,          /*  1 reset       */
    NMI_Handler,            /*  2             */
    HardFault_Handler,      /*  3             */
    /* 4-14: fault, SVC, PendSV ... */
    SysTick_Handler,        /* 15             */
    EXTI0_IRQHandler,       /* 16 = IRQ0      */
    UART_IRQHandler,        /* 17 = IRQ1      */
    0, 0, 0, 0, 0, 0        /* 18-23 unused   */
};

লাইনগুলো একে একে:

  • extern uint32_t _sidata …: এগুলো C-এর variable নয়, linker script-এর বানানো ঠিকানা-চিহ্ন। C-তে এদের ঠিকানাটাই (&_sdata) কাজের, মান নয়। _estack = SRAM-এর শীর্ষ = 0x20000000 + 20 KiB = 0x20005000.
  • WEAK: প্রতিটি handler একটি weak symbol, যার alias Default_Handler. আপনার firmware-এ একই নামের function লিখলে সেটি জেতে; না লিখলে linker টেবিলে Default_Handler-এর ঠিকানা বসায়, যা একটি অসীম loop. তাই ভুল বানানের handler (Systick_Handler) কোনো error দেয় না, শুধু interrupt এলে CPU চুপচাপ আটকে যায়। এই bug খুবই পরিচিত।
  • section(".isr_vector"): টেবিলটিকে একটি নিজস্ব section-এ রাখে, আর linker script সেটিকে flash-এর একেবারে শুরুতে বসায় (KEEP থাকায় --gc-sections একে ফেলে দেয় না)।
  • (vector_t)&_estack: টেবিলের প্রথম ঘর একটি ঠিকানা, function নয়; তাই cast. এটি এক ঘর বলেই exception নম্বর আর টেবিলের index মেলে: SysTick exception ১৫, তার handler ঘর ১৫-এ, offset 15 × 4 = 0x3C.

Build-এর পরে টেবিলে আসলে কী বসল, তা ELF থেকে পড়া হলো (সত্যিকারের run, capstone 5.0.6 আর lab-এর ELF reader দিয়ে, নিজের lab-এ):

~/lab $ python -B fwdis.py build/boot_demo.elf --vec 18
vector  0 @ 0x08000000 = 0x20005000
vector  1 @ 0x08000004 = 0x08000359
vector  2 @ 0x08000008 = 0x080002C1
vector  3 @ 0x0800000C = 0x080002C1
...
vector  7 @ 0x0800001C = 0x00000000
vector 15 @ 0x0800003C = 0x080002C1
vector 16 @ 0x08000040 = 0x080002C1
vector 17 @ 0x08000044 = 0x080002C1

ঘর ০-তে 0x20005000, ঠিক SRAM-এর শীর্ষ। ঘর ১-এ 0x08000359, অথচ symbol table বলে Reset_Handler শুরু 0x08000358-এ: linker Thumb function-এর ঠিকানায় নিজেই bit 0 = 1 যোগ করেছে। boot_demo কোনো handler লেখেনি, তাই NMI, HardFault, SysTick, EXTI0, UART সবার ঘরে একই 0x080002C1, অর্থাৎ Default_Handler (0x080002C0) + Thumb bit. ঘর ৭–১০ আর ১৩ “reserved”, তাই 0. Exception-এর পুরো তালিকা, priority আর stacking পর্ব ৩০-এ (Cortex-M-এর exception আর NVIC).

৩ · Reset_Handler — লাইন ধরে, তারপর আসল assembly

startup.c-এর দ্বিতীয় অর্ধেক হলো reset handler, মাত্র ১১ লাইন:

void Reset_Handler(void)
{
    uint32_t *src = &_sidata;          /* .data-র মান flash-এ এখানে */
    uint32_t *dst = &_sdata;           /* .data SRAM-এ এখান থেকে   */
    while (dst < &_edata)
        *dst++ = *src++;               /* (১) .data কপি            */
    for (dst = &_sbss; dst < &_ebss; )
        *dst++ = 0;                    /* (২) .bss শূন্য            */
    main();                            /* (৩) আপনার প্রোগ্রাম       */
    for (;;) { }                       /* (৪) main ফিরলে এখানে আটকে */
}

void Default_Handler(void)
{
    for (;;) { }
}

চারটি কাজ:

  1. .data কপি: int32_t rate_paisa = 6550;-এর মতো প্রাথমিক মানসহ global variable থাকে SRAM-এ (data section), কারণ প্রোগ্রাম তাদের বদলাতে পারে। কিন্তু বিদ্যুৎ গেলে SRAM মুছে যায়, তাই 6550 সংখ্যাটি flash-এ রাখা থাকে। প্রতি boot-এ সেই কপি SRAM-এ আনতে হয়। Flash-এর ঠিকানা (_sidata) আর SRAM-এর ঠিকানা (_sdata) কেন আলাদা, সেই “load address বনাম run address”-এর হিসাব পর্ব ৩১-এর বিষয়।
  2. .bss শূন্য: যে global variable-এর কোনো প্রাথমিক মান দেওয়া হয়নি (int32_t tare_g;), C ভাষা বলে সেটি শূন্য দিয়ে শুরু হবে (C11 §6.7.9). এমন variable থাকে .bss-এ। Flash-এ হাজারটা শূন্য রাখা অপচয়, তাই linker শুধু শুরু আর শেষের ঠিকানা দেয়, আর startup code নিজে শূন্য লেখে।
  3. main ডাকা: এবার C-এর সব প্রতিশ্রুতি সত্য, তাই main().
  4. অসীম loop: main কখনো ফিরলে CPU যাতে অজানা কোথাও না যায়।

একটি সূক্ষ্ম বিষয় খেয়াল করুন: দুটি loop-ই uint32_t * দিয়ে, অর্থাৎ একবারে ৪ byte. যদি .bss-এ মোট ৫ byte থাকে? Reference linker script প্রতিটি section-এর শেষে . = ALIGN(4) রাখে, তাই _edata আর _ebss সবসময় ৪-এর গুণিতক ঠিকানায় পড়ে; loop কখনো সীমার মাঝখানে আটকায় না, আর প্রতিটি word-লেখা সাজানো ঠিকানায় হয়। Linker script আর startup code এভাবে একটি চুক্তিতে বাঁধা: একটি বদলালে অন্যটিও মিলিয়ে দেখতে হয়।

লক্ষ করুন, পুরো reset handler সাধারণ C-তে লেখা, একটিও assembly লাইন নেই। এটি সম্ভব কারণ hardware নিজেই SP বসিয়ে দিয়েছে, তাই প্রথম C function-ই stack পায়। আর reference lab-এর startup-এ CMSIS-ধাঁচের SystemInit() ডাক নেই; board-এর clock সবসময় 8 MHz, সাজানোর কিছু নেই। আসল chip-এর নির্মাতার startup ফাইলে সাধারণত একটি SystemInit() ডাক থাকে, যা clock সাজায়; সেটি পর্ব ৩৩-এ (Clock, reset আর power domain).

Compiler এই ১১ লাইনকে কী বানাল

বোঝার জন্য একটি ছোট firmware boot_demo.c লেখা হলো: দুটি .data variable (rate_paisa = 6550, capacity_g = 5000), পাঁচ word-এর .bss (int32_t samples[4] আর tare_g; ওজনযন্ত্র চারটি ADC মাপের গড় নেয়), আর একটি .noinit boot counter. Reference startup.c, bglib.c আর bazarghar.ld নিজের lab-এ কপি করে board.py-এর নিজস্ব build() দিয়ে Clang 22.1.8-এ build করা হলো (ziglang 0.17.1; flag reference-এর মতোই -O2). তারপর Reset_Handler-এর disassembly (সত্যিকারের run; byte-এর কলাম আর মাঝের অংশ বাদ, ;-এর পরের মন্তব্য বোঝানোর জন্য যোগ করা):

~/lab $ python -B fwdis.py build/boot_demo.elf Reset_Handler
Reset_Handler @ 0x08000358, 130 bytes
  08000358  movw  r0, #8          ; r0 = _edata (নিচের অর্ধেক)
  0800035C  movw  r1, #0          ; r1 = _sdata
  08000360  movt  r0, #0x2000     ; r0 = 0x20000008
  08000364  movt  r1, #0x2000     ; r1 = 0x20000000
  08000368  cmp   r1, r0
  0800036A  bhs   #0x800039e      ; .data খালি হলে লাফ
  0800036C  movw  r2, #0xa08
  08000370  movt  r2, #0x800      ; r2 = _sidata = 0x08000A08
  08000374  ldr   r3, [r2]        ; flash থেকে এক word
  08000376  str   r3, [r1], #4    ; SRAM-এ লেখা, r1 += 4
  0800037A  cmp   r1, r0
  0800037C  bhs   #0x800039e
  ...                             ; আরও তিনবার (loop ৪ গুণ খোলা)
  0800039E  movw  r0, #0x1c       ; r0 = _ebss = 0x2000001C
  080003A2  movw  r1, #8          ; r1 = _sbss = 0x20000008
  ...
  080003B2  movs  r2, #0
  080003B4  str   r2, [r1], #4    ; শূন্য লেখা, r1 += 4
  ...                             ; ৪ গুণ খোলা, তারপর blo
  080003D4  bl    #0x8000060      ; main()
  080003D8  b     #0x80003d8      ; for (;;) { }

তিনটি জিনিস চোখে পড়ার মতো। প্রথমত, &_edata-র মতো linker-চিহ্ন একটি movw/movt জোড়ায় ৩২-bit ধ্রুবক হয়ে গেছে, তাই link-এর পরে এগুলো সংখ্যা মাত্র। দ্বিতীয়ত, str r3, [r1], #4 হলো post-indexed store: লেখার পরে r1 নিজে 4 বাড়ে, তাই *dst++ এক instruction-এ। তৃতীয়ত, Clang দুটি loop-ই ৪ গুণ খুলেছে (loop unrolling): প্রতি word-এ একটি str, একটি cmp আর একটি branch. ফলে function-টি 130 byte. আর ঠিকানাগুলো ছবি ৩২.১-এর সঙ্গে হুবহু মেলে।

৪ · Board-কে boot হতে দেখা — --trace

Reference board-এর run command-এ --trace N দিলে প্রথম N instruction-এর ঠিকানা আর symbol ছাপে (সত্যিকারের run):

~/lab/_ref $ python -B board.py run ../boot/build/boot_demo.elf --trace 6 --cycles 40
[     0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[     0.0001 ms] trace PC=0x08000358 Reset_Handler+0x0
[     0.0003 ms] trace PC=0x0800035C Reset_Handler+0x4
[     0.0004 ms] trace PC=0x08000360 Reset_Handler+0x8
[     0.0005 ms] trace PC=0x08000364 Reset_Handler+0xC
[     0.0006 ms] trace PC=0x08000368 Reset_Handler+0x10
[     0.0008 ms] trace PC=0x0800036A Reset_Handler+0x12
[     0.0050 ms] stopped: cycle limit (40) reached after 40 cycles

প্রথম instruction-ই 0x08000358, অর্থাৎ vector table-এর ঘর ১ থেকে আসা ঠিকানা থেকে Thumb bit বাদ দিয়ে। প্রতি লাইনে সময় 0.000125 ms বাড়ে, কারণ board ধরে নেয় ১ instruction = ১ cycle = 1 ÷ 8 MHz = 125 ns (Spec decision 17); আসল Cortex-M3-এর cycle সংখ্যা instruction-ভেদে আলাদা। Register-এর মানও দেখতে lab-এর Board class-কে না বদলে তার ওপর একটি ছোট tracer লেখা হলো (rtrace.py, নিজের lab-এ), যা প্রতিটি instruction-এর আগে register ছাপে। নিচের stepper সেই আসল trace থেকে বানানো।

1MSP ← [0x08000000]2PC  ← [0x08000004]3r0 = _edata; r1 = _sdata4cmp r1, r0; bhs (শেষ?)5r2 = _sidata6ldr r3,[r2]; str r3,[r1],#47r0 = _ebss; r1 = _sbss; r2 = 08bl main
Register আর SRAM (ধাপের পরে)
PC
MSP
LR
r0
r1
r2
r3
.data
  1. Reset: hardware-এর কাজ. কোনো instruction চলার আগেই board 0x08000000 থেকে MSP = 0x20005000 আর 0x08000004 থেকে 0x08000359 পড়ে, Thumb bit বাদ দিয়ে PC = 0x08000358. LR = 0xFFFFFFFF, R0–R12 = 0 (Spec decision 18).
  2. .data-র সীমা. চারটি movw/movt: r0 = _edata = 0x20000008, r1 = _sdata = 0x20000000. মাঝে ৮ byte, অর্থাৎ দুটি word: rate_paisa আর capacity_g.
  3. কিছু কপি করার আছে? cmp r1, r0: 0x20000000 < 0x20000008, তাই bhs (unsigned ≥ হলে লাফ) লাফ দেয় না। .data খালি হলে এখানেই loop এড়ানো হতো।
  4. উৎসের ঠিকানা. r2 = _sidata = 0x08000A08, flash-এ code-এর ঠিক পরে যেখানে linker প্রাথমিক মানগুলো রেখেছে।
  5. প্রথম word কপি. ldr r3, [r2] flash থেকে 0x1996 = 6550 আনে, str r3, [r1], #4 তা 0x20000000-এ লেখে আর r1 = 0x20000004 করে। এখন rate_paisa = 6550, অর্থাৎ 65.50 টাকা/kg.
  6. দ্বিতীয় word, তারপর শেষ. 0x1388 = 5000 (capacity_g) 0x20000004-এ গেল, r1 = 0x20000008 = r0, তাই এবার bhs লাফ দিয়ে 0x0800039E-এ, .bss অংশে। ১৬টি instruction-এ .data শেষ।
  7. .bss-এর প্রস্তুতি. r0 = _ebss = 0x2000001C, r1 = _sbss = 0x20000008, r2 = 0. মাঝে ২০ byte = ৫টি word: samples[0..3] আর tare_g. শূন্য লেখার loop পরের stepper-এ ধাপে ধাপে।
  8. bl main. ৫টি word শূন্য হওয়ার পরে ৩৯তম instruction bl main: PC = 0x08000060, LR = 0x080003D9 (ফেরার ঠিকানা 0x080003D8, সঙ্গে Thumb bit). Board-এর মডেলে ৩৯ cycle = 4.875 µs; আসল chip-এ সময় তার নিজের timing থেকে।

এবার পুরো firmware চালানো হলো। boot_demo প্রথম boot-এ নিজের তথ্য ছাপে, তারপর RAM-এ tare = 150 g, rate = 7000 আর চারটি sample = 505 বসিয়ে SCB->AIRCR-এ SYSRESETREQ লিখে software reset করে। দ্বিতীয় boot-এ আবার ছাপে, তারপর main() থেকে ফিরে যায় (সত্যিকারের run):

~/lab/_ref $ python -B board.py run ../boot/build/boot_demo.elf --cycles 200000
[     0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[     0.0301 ms] UART: boot #1 (power-on)
[     0.0940 ms] UART: VTOR=0x08000000 MSP0=0x20005000 RESET=0x08000359
[     0.1596 ms] UART: sidata=0x08000A08 sdata=0x20000000 edata=0x20000008
[     0.2206 ms] UART: sbss=0x20000008 ebss=0x2000001C SP=0x20004FD8
[     0.2841 ms] UART: rate=6550 cap=5000 tare=0 avg_raw=0
[     0.3412 ms] UART: 1400 g on the scale -> net=1400 g price=91.70 Tk
[     0.3867 ms] UART: RAM now: tare=150 rate=7000 samples=505; software reset
[     0.3877 ms] RESET (software, AIRCR.SYSRESETREQ)
[     0.4224 ms] UART: boot #2 (software reset)
...                                  (ঠিকানার তিনটি লাইন আগের মতোই)
[     0.6764 ms] UART: rate=6550 cap=5000 tare=0 avg_raw=0
[     0.7335 ms] UART: 1400 g on the scale -> net=1400 g price=91.70 Tk
[     0.7504 ms] UART: main() returns now
[    25.0000 ms] stopped: cycle limit (200000) reached after 200000 cycles

দ্বিতীয় boot-এ rate আবার 6550, কারণ .data প্রতিবার flash থেকে কপি হয়; tare আর sample আবার 0, কারণ .bss প্রতিবার শূন্য হয়। দাম (1400 × 6550 + 500) ÷ 1000 = 9170 paisa = 91.70 টাকা, দুবারই একই। কিন্তু boot counter 2 হয়েছে: সেটি .noinit-এ, যাকে startup ছোঁয় না, আর board-এ SRAM software ও watchdog reset-এ টিকে থাকে (Spec decision 18). main-এ SP = 0x20004FD8: 0x20005000 থেকে main-এর নিজের ৪০ byte (৯টি register push আর ৪ byte জায়গা)। শেষ লাইনের রহস্য ষষ্ঠ অংশে।

৫ · .bss শূন্য না করলে কী ভাঙে

দ্বিতীয় boot-এর সময় .bss-এর loop-টি ধাপে ধাপে দেখুন। এখানে SRAM-এ আগের boot-এর ময়লা আছে, তাই শূন্য লেখা সত্যিই কাজে লাগছে:

1    movs r2, #02L:  str  r2, [r1], #43    cmp  r1, r0 ; bhs done4    (×4 খোলা) blo L5done: bl main
SRAM (দশমিকে) আর r1
r1
samples[0]
samples[1]
samples[2]
samples[3]
tare_g
boot_no
  1. শুরুর অবস্থা. Software reset-এর পরে SRAM আগের মতোই: চারটি sample 505 (150 g-এর ADC count), tare_g = 150. .data-র কপি ইতিমধ্যে rate 7000 থেকে 6550 করেছে। r1 = 0x20000008, r0 = 0x2000001C. boot_no (0x2000001C) .bss-এর বাইরে, main এটিকে 1 থেকে 2 করবে।
  2. প্রথম str. samples[0] = 0, r1 = 0x2000000C. cmp: তখনো r1 < r0, তাই bhs লাফ দেয় না।
  3. দ্বিতীয়. samples[1] = 0, r1 = 0x20000010.
  4. তৃতীয়. samples[2] = 0, r1 = 0x20000014.
  5. চতুর্থ, loop-এর শেষ. samples[3] = 0, r1 = 0x20000018. Clang loop-টি ৪ গুণ খুলেছিল, তাই এখানে blo L loop-এর মাথায় ফিরে যায়।
  6. পঞ্চম, তারপর main. tare_g = 0, r1 = 0x2000001C = r0. এবার bhs লাফ দেয়, আর bl main. ৫টি word-এ ১৫টি instruction (প্রতি word-এ str, cmp, branch), আগের ৭টি প্রস্তুতি সহ ২২টি।
  7. Loop না থাকলে. একই firmware-এ loop মুছে দিলে (নিচের run) সব মান বামের ঘর থেকে ডানের ঘরে যায় না: “∣”-এর ডানে ভুল startup-এর মান। main পুরোনো tare 150 g দেখে, তাই 1400 g-এ net 1250 g আর দাম 81.88 টাকা, যেখানে হওয়া উচিত 91.70.

কথাটি আসল run দিয়ে যাচাই করা হলো। startup.c-এর একটি কপিতে .bss loop-এর দুই লাইন মুছে (startup_nobss.c) একই boot_demo build করা হলো। Reset_Handler 130 থেকে 78 byte-এ নামল, অর্থাৎ শূন্য করার কোড ছিল 52 byte. Run-এর দ্বিতীয় boot (সত্যিকারের run):

~/lab $ python -B mk.py fw build/boot_nobss.elf fw/boot_demo.c --startup fw/startup_nobss.c
built boot_nobss.elf
~/lab/_ref $ python -B board.py run ../boot/build/boot_nobss.elf --cycles 200000
...
[     0.3045 ms] UART: rate=6550 tare=0 g ...     (boot #1: সব ঠিক দেখায়)
[     0.3850 ms] RESET (software, AIRCR.SYSRESETREQ)
[     0.4169 ms] UART: boot #2 (software reset)
...
[     0.6796 ms] UART: rate=6550 cap=5000 tare=150 avg_raw=505
[     0.7368 ms] UART: 1400 g on the scale -> net=1250 g price=81.88 Tk
[     0.7536 ms] UART: main() returns now

(প্রথম boot-এর লাইনগুলোর মাঝের অংশ সংক্ষেপ করা।) সবচেয়ে বিপজ্জনক অংশ প্রথম boot: সেখানে সব ঠিক দেখায়, কারণ board-এ power-on-এ SRAM পুরো শূন্য (Spec decision 18). তাই lab-এ বা প্রথম পরীক্ষায় bug ধরা পড়ে না; ধরা পড়ে মাঠে, প্রথম watchdog বা software reset-এর পরে। rate কিন্তু ঠিক 6550, কারণ .data-র কপি তখনো আছে। আসল chip-এ power-on-এ SRAM-এর মান নিশ্চিত নয়; ঠিক কী থাকে তা chip আর পরিস্থিতির ওপর নির্ভর করে, তাই সেখানে প্রথম boot-এও ময়লা আসতে পারে।

দুই জগতের পার্থক্য একসাথে দেখতে নিচের ছোট মডেলটি চালান। এটি Reset_Handler-এর কাজ Python dictionary-তে অনুকরণ করে। আসল chip-এর SRAM-কে মডেলে একটি নির্দিষ্ট seed-এর এলোমেলো সংখ্যা দিয়ে ভরা হয়েছে; এটি বাস্তবের মাপা মান নয়, শুধু “অনির্ধারিত” বোঝানোর উপায়।

# Reset_Handler-এর একটি ছোট মডেল: .data কপি, .bss শূন্য, তারপর main
import random
DATA_INIT = {"rate_paisa": 6550, "capacity_g": 5000}  # flash-এ রাখা প্রাথমিক মান
BSS = ["s0", "s1", "s2", "s3", "tare_g"]               # samples[4] আর tare_g

def reset_handler(ram, zero_bss):
    ram.update(DATA_INIT)                 # .data: flash থেকে SRAM-এ কপি
    if zero_bss:
        for k in BSS:                     # .bss: শূন্য দিয়ে ভরা
            ram[k] = 0

def main(ram, boot):
    net = 1400 - ram["tare_g"]            # পাল্লায় 1400 g
    p = (net * ram["rate_paisa"] + 500) // 1000
    print(f"  boot #{boot}: tare={ram['tare_g']} net={net} g price={p // 100}.{p % 100:02d} Tk")
    ram.update(tare_g=150, rate_paisa=7000, s0=505, s1=505, s2=505, s3=505)

random.seed(32)
starts = {"board (Spec 18: SRAM শূন্য)": 0, "আসল chip (মডেল: এলোমেলো)": None}
for label, fill in starts.items():
    for zero in (True, False):
        ram = {k: (fill if fill is not None else random.getrandbits(12))
               for k in list(DATA_INIT) + BSS}
        print(f"{label}, .bss শূন্য করা = {zero}")
        for boot in (1, 2):               # boot 1, তারপর software reset
            reset_handler(ram, zero)
            main(ram, boot)

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

board (Spec 18: SRAM শূন্য), .bss শূন্য করা = True
  boot #1: tare=0 net=1400 g price=91.70 Tk
  boot #2: tare=0 net=1400 g price=91.70 Tk
board (Spec 18: SRAM শূন্য), .bss শূন্য করা = False
  boot #1: tare=0 net=1400 g price=91.70 Tk
  boot #2: tare=150 net=1250 g price=81.88 Tk
আসল chip (মডেল: এলোমেলো), .bss শূন্য করা = True
  boot #1: tare=0 net=1400 g price=91.70 Tk
  boot #2: tare=0 net=1400 g price=91.70 Tk
আসল chip (মডেল: এলোমেলো), .bss শূন্য করা = False
  boot #1: tare=1330 net=70 g price=4.59 Tk
  boot #2: tare=150 net=1250 g price=81.88 Tk

দ্বিতীয় ব্লক board-এর আসল run-এর সঙ্গে হুবহু মেলে: 81.88 টাকা। চতুর্থ ব্লকে মডেলের এলোমেলো SRAM-এ প্রথম boot-এই tare 1330 g, ফলে 1400 g-এর জিনিসের দাম মাত্র 4.59 টাকা: দোকানের সরাসরি লোকসান। .bss শূন্য করলে চারটি পরিস্থিতিতেই একই, সঠিক উত্তর। Startup code-এর কাজ এই নিশ্চয়তাটুকু দেওয়া।

৬ · main() ফিরে এলে কী হয়

PC-তে main() শেষ হলে operating system প্রোগ্রাম বন্ধ করে। কিন্তু microcontroller-এ ফেরার কোনো জায়গা নেই: firmware-ই একমাত্র প্রোগ্রাম। C মানদণ্ড এই পরিবেশকে freestanding environment বলে, আর সেখানে প্রোগ্রাম কীভাবে শুরু আর শেষ হয়, তা implementation ঠিক করে (C11 §5.1.2.1). তাই উত্তরটি নির্ভর করে আপনার startup code-এর ওপর।

Reference startup-এর উত্তর for (;;) { }, একটি infinite loop. আগের run-এর শেষ লাইন “stopped: cycle limit (200000) reached” সেটিই দেখায়। Tracer দিয়ে শেষ কয়েকটি instruction দেখা হলো (সত্যিকারের run):

~/lab $ python -B rtrace.py build/boot_demo.elf --last 3 --cycles 200000 --regs r0,sp,lr
...                                  (board-এর UART লাইনগুলো বাদ)
--- last 3 instructions ---
199998 080003D8 Reset_Handler+0x80     b #0x80003d8   | r0=00000000 sp=20005000 lr=080002DB
199999 080003D8 Reset_Handler+0x80     b #0x80003d8   | r0=00000000 sp=20005000 lr=080002DB
200000 080003D8 Reset_Handler+0x80     b #0x80003d8   | r0=00000000 sp=20005000 lr=080002DB

CPU একই ঠিকানায় নিজের দিকে লাফাচ্ছে। r0 = 0 হলো main-এর return 0. SP ফিরে গেছে 0x20005000-এ। নিরাপদ, কিন্তু অকেজো: interrupt চালু থাকলে তা চলতে পারে, অথচ মূল কাজ বন্ধ, আর watchdog চালু থাকলে কিছুক্ষণ পরে reset.

Loop না থাকলে — LR = 0xFFFFFFFF-এর অর্থ

এবার startup-এর আরেকটি কপিতে main();-এর পরের অসীম loop মুছে দেওয়া হলো (startup_noloop.c). Compiler তখন bl main-এর বদলে b.w main দিল, অর্থাৎ tail call: Reset_Handler-এর আর কিছু করার নেই, তাই main সরাসরি Reset_Handler-কে যে ডেকেছে তার কাছে ফিরবে। কিন্তু Reset_Handler-কে কেউ ডাকেনি, hardware চালু করেছে, আর তখন LR ছিল reset মান 0xFFFFFFFF (সত্যিকারের run):

~/lab $ python -B rtrace.py build/boot_noloop.elf --last 3 --regs r0,sp,lr
...                                  (board-এর UART লাইনগুলো বাদ)
error: EXC_RETURN 0xFFFFFFFF outside an exception handler
--- last 3 instructions ---
  6009 080002DA main+0x27A    movs r0, #0                 | r0=08000933 sp=20004FD8 lr=080002DB
  6010 080002DC main+0x27C    add sp, #4                  | r0=00000000 sp=20004FD8 lr=080002DB
  6011 080002DE main+0x27E    pop.w {r4, r5, r6, r7, r8, sb, sl, fp, pc} | r0=00000000 sp=20004FDC lr=080002DB

main-এর শুরুতে push যে LR stack-এ রেখেছিল, তা 0xFFFFFFFF (tracer-এ main+0x0-তে lr=FFFFFFFF দেখা গেছে); শেষে pop {…, pc} সেটিই PC-তে তোলে। 0xFFFFFFF_-ধাঁচের ঠিকানা Cortex-M-এ exception থেকে ফেরার বিশেষ সংকেত, তাই board থেমে বলে, exception handler-এর বাইরে এমন ফেরা অর্থহীন (Spec decision 19). আসল Cortex-M3-এ thread mode থেকে এমন ঠিকানায় লাফ দিলে সাধারণত একটি fault হয়, যা শেষে HardFault-এ যায়। ARM ইচ্ছে করেই reset-এ LR-কে এই অবৈধ মান দেয়, যাতে ফেরার চেষ্টা নীরবে অজানা কোডে না গিয়ে ধরা পড়ে।

ভালো firmware-এ main() কখনো ফেরে না: ভেতরে একটি super loop বা RTOS-এর scheduler চলে (পর্ব ৫৫, Super loop আর state machine). তবু startup-এ শেষ রক্ষা রাখা ভালো অভ্যাস: অসীম loop, ত্রুটির চিহ্ন রেখে reset, বা নিরাপদ অবস্থায় যন্ত্র রেখে ঘুম। ঠান্ডা ঘরের monitor-এর জন্য “চুপচাপ আটকে থাকা” সবচেয়ে খারাপ, কারণ alarm-ও তখন বন্ধ; সেখানে watchdog-এর reset বেশি নিরাপদ (পর্ব ৬১, Watchdog আর fault handling).

৭ · C runtime-এর অনুমান — main-এর আগে কী সত্য হতে হবে

C কোড লেখার সময় আপনি কয়েকটি কথা না ভেবেই ধরে নেন। Hosted পরিবেশে (PC-তে) OS আর C library এগুলো সত্য করে; PC-র দিকটি C কোর্সের পর্ব ০৩-এ আর loader-এর দিকটি PLC কোর্সের Linking আর loading (পর্ব ৭৪)-এ। Bare-metal-এ সেই দায়িত্ব startup code-এর:

C-এর অনুমানকে সত্য করে (BG-M3)না হলে কী হয়
বৈধ stack আছেHardware: vector ঘর ০ থেকে MSPপ্রথম function call-এই fault
প্রাথমিক মানসহ global-এর মান ঠিকReset_Handler-এর .data কপিrate_paisa = ময়লা, ভুল দাম
মানহীন global শূন্যReset_Handler-এর .bss looptare 150 g থেকে যায়, 81.88 টাকা
memcpy/memset আছেstartup.c-এর নিচের দুটি functionLink error: compiler নিজেই এগুলো ডাকে
Clock আর flash-এর গতি ঠিকBoard-এ স্থির 8 MHz; আসল chip-এ SystemInit()UART-এর baud ভুল, timing ভুল
FPU চালু (float থাকলে)Cortex-M3-এ FPU নেই; M4F-এ startup-কে চালু করতে হয়প্রথম float instruction-এ fault
C++ global object তৈরিReference startup করে না (C-only)Constructor চলে না

memcpy-এর সারিটি অনেককে অবাক করে। -ffreestanding -nostdlib দিয়ে build করলেও Clang বড় struct কপি বা array শূন্য করার জন্য নিজে থেকে memcpy বা memset ডাকতে পারে; তাই reference lab এগুলো startup.c-তে নিজেই দিয়েছে। আর নিজের .bss loop-কে compiler memset-এ বদলে দিলে সেই memset নিজে যেন .bss-এর কিছুতে নির্ভর না করে, এটিও startup লেখকের ভাবনার বিষয়।

আরেকটি সূক্ষ্ম অনুমান: .data কপি আর .bss শূন্য হওয়ার আগে কোনো C কোড global variable ছুঁতে পারবে না। তাই নির্মাতার startup-এ SystemInit() যদি কপির আগে ডাকা হয়, তার ভেতরে global ব্যবহার একটি অপেক্ষমাণ bug. কোন নির্মাতা কোন ক্রমে ডাকে, তা তার startup ফাইল খুলে দেখবেন; সংস্করণভেদে ক্রম বদলেছে বলেও জানা যায়।

আরও গভীরে: পুরোনো ARM7TDMI-র মতো core reset-এ ঠিকানা 0 থেকে একটি instruction চালাত, তাই প্রতিটি mode-এর stack বসাতে assembly-র startup লাগত। Cortex-M-এর নকশায় (Cortex-M3, ২০০৪–০৫) টেবিলের প্রথম ঘরে SP রাখা হলো, handler-এর ঘরে সরাসরি C function-এর ঠিকানা, আর exception-এ register-গুলো hardware নিজে stack-এ রাখে; ফলে startup থেকে interrupt handler পর্যন্ত সব C-তে লেখা যায়। ARMv7-M Architecture Reference Manual-এর reset-এর বর্ণনায় (TakeReset) SP, PC, LR আর EPSR-এর এই নিয়মগুলো pseudocode হিসেবে দেওয়া আছে; VTOR-এর কোন bit লেখা যায় তা core-এর revision-ভেদে আলাদা, তাই নিজের core-এর Technical Reference Manual দেখবেন।

৮ · Bootloader — একটি firmware থেকে আরেকটিতে লাফ

এতক্ষণ reset-এর পরে সরাসরি আপনার firmware চলেছে। বাস্তবে অনেক যন্ত্রে মাঝে আরেকটি ছোট প্রোগ্রাম থাকে: bootloader. তার কাজ নতুন firmware নেওয়া (USB, UART বা wireless দিয়ে), যাচাই করা, flash-এ লেখা, তারপর আসল application চালু করা। দুই রকম bootloader চেনা দরকার।

ROM bootloader — chip-এর ভেতরে কারখানা থেকে

অনেক chip-এ নির্মাতা একটি ROM bootloader রেখে দেন, যা মোছা যায় না। উদাহরণ হিসেবে (নিজের chip-এর নথিতে মিলিয়ে নেবেন): STM32F103-এ BOOT0 আর BOOT1 pin দিয়ে reset-এর সময় main flash, “system memory” বা SRAM থেকে চালু হওয়া বাছা যায়, আর system memory-তে ST-এর bootloader থাকে যা UART দিয়ে firmware নিতে পারে (RM0008); ESP32-এ chip-এর boot ROM নির্দিষ্ট strapping pin দেখে download mode-এ যায় বা flash থেকে পরের ধাপ চালায়; RP2040-এ BOOTSEL বোতাম চেপে চালু করলে boot ROM USB-তে একটি drive-এর মতো দেখা দেয়। এমন pin-কে বলা যায় boot mode pin. সুবিধা: firmware যত খারাপই হোক, chip “brick” হয় না।

নিজের bootloader আর application

নিজের bootloader লিখলে flash দুই ভাগ হয়: শুরুতে bootloader, পরে application, যার নিজস্ব vector table. বাজারঘরের জন্য একটি ছোট নমুনা বানানো হলো: bootloader.c 0x08000000-এ, app.c 0x08004000-এ (linker script-এর কপিতে একটি .app section যোগ করে)। Application-এর টেবিলের ঘর ১৫-এ নিজের App_SysTick; bootloader-এর টেবিলে SysTick-এর ঘরে Default_Handler (অসীম loop). তাই SysTick ঠিকমতো গোনা হলে প্রমাণ হয় VTOR সত্যিই বদলেছে। Bootloader-এর মূল অংশ:

#define APP_BASE 0x08004000u

const uint32_t *app = (const uint32_t *)APP_BASE;
uint32_t app_sp = app[0], app_reset = app[1];
/* ... UART-এ দুটি মান ছাপা ... */
if (app_sp < SRAM_BASE || app_sp > SRAM_BASE + 20u * 1024u ||
    (app_reset & 1u) == 0u || app_reset < APP_BASE ||
    app_reset >= FLASH_BASE + 128u * 1024u) {
    uart_puts("bootloader: no valid application, staying here\r\n");
    board_exit(1);
}
__disable_irq();
SysTick->CTRL = 0;                /* peripheral শান্ত রেখে যাওয়া */
SCB->VTOR = APP_BASE;             /* exception এখন app-এর টেবিলে */
__asm volatile ("msr msp, %0\n\tbx %1"
                :: "r"(app_sp), "r"(app_reset) : "memory");

দুটি build চালানো হলো: application সহ (bl.elf) আর application ছাড়া (bl_noapp.elf), সত্যিকারের run:

~/lab/_ref $ python -B board.py run ../boot/build/bl.elf
[     0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[     0.0424 ms] UART: bootloader: app vector table at 0x08004000
[     0.0931 ms] UART: bootloader: app SP=0x20005000 reset=0x08004051
[     0.1356 ms] UART: bootloader: VTOR <- 0x08004000, MSP <- app SP, jump
[     0.1613 ms] UART: app: started, VTOR=0x08004000
[     3.2015 ms] UART: app: 3 SysTick interrupts served by App_SysTick
[     3.2022 ms] exit(0) after 25618 cycles
~/lab/_ref $ python -B board.py run ../boot/build/bl_noapp.elf
...
[     0.0931 ms] UART: bootloader: app SP=0x00000000 reset=0x00000000
[     0.1311 ms] UART: bootloader: no valid application, staying here
[     0.1320 ms] exit(1) after 1056 cycles

Application-এর দিক থেকেও দুটি শর্ত আছে। প্রথমত, তাকে নিজের ঠিকানায় (এখানে 0x08004000) link করতে হয়; 0x08000000-এর জন্য বানানো firmware এই slot-এ বসালে তার প্রতিটি ঠিকানা ভুল। দ্বিতীয়ত, application-এর নিজের reset handler-কেও আবার নিজের .data কপি আর .bss শূন্য করতে হয়, কারণ bootloader-এর startup শুধু নিজের variable সাজিয়েছে। এই নমুনার app সরল রাখতে কোনো .data বা .bss রাখেনি, শুধু একটি .noinit counter, যাকে সে নিজেই 0 বসায়; আসল প্রকল্পে application-এর আলাদা linker script আর পূর্ণ startup থাকে।

1reset: টেবিল 0x080000002r4,r5 = app[0], app[1]3SP, Thumb, সীমা যাচাই4cpsid i; SysTick বন্ধ5VTOR = 0x080040006msr msp, r47bx r5 → App_Reset8SysTick → ঘর ১৫ (app)
অবস্থা (ধাপের পরে)
VTOR
r4 (app SP)
r5 (app reset)
MSP
PC
PRIMASK
  1. Reset: bootloader-এর পালা. VTOR = 0x08000000, তাই hardware bootloader-এর টেবিল থেকে MSP = 0x20005000 আর তার Reset_Handler নেয়। Bootloader-এর নিজের startup .data/.bss সাজিয়ে তার main ডাকে।
  2. Application-এর টেবিল পড়া. ldrd r4, r5, [r6]: r6 = 0x08004000 থেকে এক instruction-এ দুটি word. r4 = 0x20005000 (app-এর MSP), r5 = 0x08004051 (App_Reset 0x08004050 + Thumb bit). UART-এ দুটি মান ছাপা হয়।
  3. বিশ্বাসযোগ্য কি? SP SRAM-এর ভেতরে, reset-এর bit 0 = 1, ঠিকানা 0x08004000 থেকে flash-এর শেষের মধ্যে: তিন শর্তই পাস। খালি slot-এ (board-এ flash শূন্য) এখানেই “no valid application” আর exit(1).
  4. পরিবেশ শান্ত করা. cpsid i দিয়ে PRIMASK = 1 আর SysTick-এর CTRL = 0. লাফের মাঝপথে bootloader-এর কোনো interrupt এলে ভুল handler চলত।
  5. VTOR বদল. str r6, [r0]: 0xE000ED08-এ 0x08004000. এখন থেকে সব exception application-এর টেবিল দেখবে। Board ঠিকানার নিচের ৭ bit ফেলে দেয়, তাই টেবিল ১২৮ byte-এ সাজানো চাই (0x08004000 তাই)।
  6. MSP বসানো. msr msp, r4. এখানে দুই firmware-ই SRAM-এর শীর্ষ ব্যবহার করে, তাই মান বদলায়নি (0x20005000); আলাদা হলে এই instruction-ই stack সরাত। এটি C-তে লেখা যায় না, তাই inline assembly.
  7. লাফ. bx r5: bit 0 = 1 বলে Thumb-এ থেকে PC = 0x08004050, App_Reset. trace-এ এটি ১০৯৮তম instruction. App_Reset প্রথমে cpsie i দিয়ে PRIMASK আবার 0 করে, তারপর UART-এ “app: started”.
  8. প্রমাণ: SysTick. App SysTick 1 ms-এ চালু করে। Exception ১৫ এলে board VTOR + 0x3C = 0x0800403C থেকে 0x08004041 পড়ে, তাই App_SysTick চলে, Default_Handler নয়। ৩টি tick পরে 3.2015 ms-এ শেষ বার্তা আর exit(0).

Bootloader-এর যাচাইটি host-এ আলাদা করে চালিয়ে দেখুন। নিচের program bootloader.c-এর একই তিনটি শর্ত কয়েকটি সম্ভাব্য টেবিলে চালায়, আর VTOR-এর সাজানোর নিয়মও দেখায়:

# bootloader.c-এর একই পরীক্ষা: app-এর vector table-এর প্রথম দুটি word কি বিশ্বাসযোগ্য?
SRAM_LO, SRAM_HI = 0x20000000, 0x20000000 + 20 * 1024
APP_BASE, FLASH_END = 0x08004000, 0x08000000 + 128 * 1024

def problems(sp, reset):
    p = []
    if not (SRAM_LO <= sp <= SRAM_HI):
        p.append("SP SRAM-এর বাইরে")
    if reset & 1 == 0:
        p.append("Thumb bit 0")
    if not (APP_BASE <= reset < FLASH_END):
        p.append("reset app-অংশের বাইরে")
    return p

cases = [
    ("bl.elf-এর app",          0x20005000, 0x08004051),
    ("খালি slot (board)",       0x00000000, 0x00000000),
    ("মোছা flash (আসল chip)",   0xFFFFFFFF, 0xFFFFFFFF),
    ("Thumb bit ভুলে গেছে",     0x20005000, 0x08004050),
    ("bootloader-এর নিজের",     0x20005000, 0x08000359),
]
for name, sp, rv in cases:
    p = problems(sp, rv)
    verdict = "jump" if not p else "বাতিল: " + ", ".join(p)
    print(f"{name:22} SP=0x{sp:08X} reset=0x{rv:08X} -> {verdict}")

# VTOR-এ লেখা ঠিকানার নিচের 7 bit board ফেলে দেয় (& 0xFFFFFF80)
for base in (0x08004000, 0x08004010):
    print(f"VTOR <- 0x{base:08X}: থাকে 0x{base & 0xFFFFFF80:08X}",
          "(ঠিক)" if base % 128 == 0 else "(128 byte-এ সাজানো নয়!)")

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

bl.elf-এর app          SP=0x20005000 reset=0x08004051 -> jump
খালি slot (board)      SP=0x00000000 reset=0x00000000 -> বাতিল: SP SRAM-এর বাইরে, Thumb bit 0, reset app-অংশের বাইরে
মোছা flash (আসল chip)  SP=0xFFFFFFFF reset=0xFFFFFFFF -> বাতিল: SP SRAM-এর বাইরে, reset app-অংশের বাইরে
Thumb bit ভুলে গেছে    SP=0x20005000 reset=0x08004050 -> বাতিল: Thumb bit 0
bootloader-এর নিজের    SP=0x20005000 reset=0x08000359 -> বাতিল: reset app-অংশের বাইরে
VTOR <- 0x08004000: থাকে 0x08004000 (ঠিক)
VTOR <- 0x08004010: থাকে 0x08004000 (128 byte-এ সাজানো নয়!)

প্রথম দুটি সারি board-এর দুটি আসল run-এর সঙ্গে মেলে। আসল chip-এ মোছা flash সাধারণত 0xFF পড়ে, তাই 0xFFFFFFFF-এর bit 0 = 1 হলেও SP-র শর্তে ধরা পড়ে; একটি শর্তে ভরসা না করে কয়েকটি একসাথে রাখার কারণ এটিই। শেষ সারি দেখায়, সাজানো নয় এমন ঠিকানা VTOR-এ লিখলে টেবিল চুপচাপ অন্য জায়গায় খোঁজা হয়: board-এ ১২৮ byte-এর সাজানো লাগে; আসল ARMv7-M chip-এ ন্যূনতম সাজানোও ১২৮ byte, আর exception-এর সংখ্যা বেশি হলে আরও বড়, তাই নিজের chip-এর নথি দেখবেন।

এই তিন শর্ত শুধু “ভুল করে খালি জায়গায় লাফ” ঠেকায়, কেউ ইচ্ছে করে বদলানো firmware বসালে ঠেকায় না। ভাঙা update (বিদ্যুৎ চলে গেলে অর্ধেক লেখা image) ধরতে CRC, আর বদলানো firmware ধরতে ডিজিটাল signature লাগে; সেই secure boot আর নিরাপদ update পর্ব ৭৭-এ (Secure boot আর নিরাপদ firmware update). PC-র boot ধাপের (BIOS/UEFI থেকে bootloader থেকে kernel) সঙ্গে তুলনা করতে Operating Systems কোর্সের Boot প্রক্রিয়া (পর্ব ০৭) পড়তে পারেন।

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

  • Cortex-M reset-এর পরে প্রথম কী পড়ে? Vector table-এর word 0 → MSP, word 1 → PC (reset handler); bit 0 যায় Thumb bit-এ।
  • 8085, 8086 আর Cortex-M-এর reset-এর শুরু? 8085: PC = 0000H; 8086: CS:IP = FFFFH:0000H, অর্থাৎ FFFF0H; Cortex-M: টেবিল থেকে পড়া ঠিকানা।
  • Startup code .data আর .bss-এ কী করে? .data-র প্রাথমিক মান flash থেকে SRAM-এ কপি, .bss শূন্য, তারপর main.
  • Embedded-এ main ফিরলে কী হয়? Startup যা ঠিক করেছে: সাধারণত অসীম loop বা reset; C মানদণ্ডে freestanding পরিবেশে এটি implementation-এর ওপর।
  • Bootloader-এর পরে VTOR কেন বদলাতে হয়? নইলে interrupt bootloader-এর টেবিলের handler-এ যায়; app-এর টেবিলের ঠিকানা VTOR-এ লিখে MSP বসিয়ে reset vector-এ লাফ।

৯ · AI-এর যুগে — startup আর bootloader-এর কোড যাচাই

AI assistant একটি “minimal Cortex-M startup” খুব দ্রুত লিখে দেয়, আর বেশিরভাগ সময় দেখতে ঠিক লাগে। কিন্তু boot-এর ভুল সবচেয়ে কম দৃশ্যমান: প্রথম power-on-এ সব ঠিক চলে, ভুল আসে মাঠে, reset-এর পরে। এই বিষয়ে চোখে পড়ার মতো ভুলগুলো:

AI-এর সাধারণ ভুলকীভাবে ধরবেন
.bss loop বাদ দেওয়া, বা “SRAM তো শুরুতে শূন্য” বলাSoftware reset সহ পরীক্ষা: boot #2-এ মান দেখা (এই পর্বের board run)
dst <= &_ebss লেখা (এক word বেশি)Map file-এ _ebss-এর ঠিক পরে কী আছে দেখা
Vector table-এ handler-এর ক্রম ভুল, বা reserved ঘর বাদELF থেকে টেবিল dump করে exception নম্বর × 4 মেলানো
Bootloader-এর লাফে VTOR বা MSP বসাতে ভুলে যাওয়া, interrupt চালু রেখে লাফApp-এর SysTick গোনা: কোন handler চলল, trace-এ দেখা
Reset vector-এ Thumb bit ছাড়া ঠিকানা হাতে বসানোELF-এর symbol ঠিকানা আর টেবিলের মানের পার্থক্য 1 কি না
নির্দিষ্ট chip-এর BOOT pin বা ROM bootloader-এর ঠিকানা বানিয়ে বলানির্মাতার reference manual-এর boot configuration অধ্যায়
Bootloader-এ শুধু CRC দিয়ে “নিরাপদ” দাবিCRC ভুল ধরে, জাল নয়; signature-এর জন্য পর্ব ৭৭

AI-কে startup বা bootloader লেখাতে চাইলে চিপ, memory map আর পরীক্ষার পরিকল্পনা স্পষ্ট দিন, আর অনুমান লুকাতে না দিন:

আমি একটি Cortex-M3 microcontroller-এর জন্য C-তে startup code লিখছি। Flash 0x08000000 থেকে 128 KB, SRAM 0x20000000 থেকে 20 KB. Linker script _sidata, _sdata, _edata, _sbss, _ebss, _estack দেয়। ১. Reset_Handler লেখো: .data কপি, .bss শূন্য, তারপর main; main ফিরলে কী হবে তা স্পষ্ট করে বলো। ২. প্রতিটি লাইনের পাশে কেন লাগে লেখো, আর C মানদণ্ড বা ARMv7-M manual-এর কোন নিয়ম এর পেছনে, তা উল্লেখ করো; নিশ্চিত না হলে “নিশ্চিত নই” লেখো। ৩. কোনো নির্দিষ্ট chip-এর register ঠিকানা বা BOOT pin-এর নিয়ম অনুমান করে লিখবে না। ৪. শেষে বলো, power-on আর software reset দুই অবস্থায় আমি কী পরীক্ষা চালিয়ে .bss আর .data যাচাই করব।

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

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

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

প্র ০১8085 আর 8086 reset-এ একটি নির্দিষ্ট ঠিকানা থেকে instruction চালায়, অথচ Cortex-M একটি টেবিল থেকে SP আর PC পড়ে। এই নকশা-পরিবর্তন firmware লেখকের জীবনে কী বদলাল?

8085 (১৯৭৬) আর 8086 (১৯৭৮)-এর যুগে CPU-র কাছে reset মানে শুধু “এই ঠিকানা থেকে পড়া শুরু করা”। 8085-এ সেটি 0000H, 8086-এ FFFF0H, যেখানে সাধারণত একটি jump থাকে। Stack pointer-এর কোনো বৈধ মান তখন নেই; তাই প্রথম কাজ assembly-তে SP বসানো, তারপর অন্য সব। C compiler-এর জগতে এর অর্থ হলো, প্রতিটি প্রকল্পে অন্তত কয়েক লাইন assembly-র startup লাগত, যা chip আর assembler-ভেদে আলাদা।

ARM-এর পুরোনো core-গুলোও (যেমন ARM7TDMI) reset-এ ঠিকানা 0 থেকে একটি instruction চালাত, আর তাদের প্রতিটি processor mode-এর আলাদা stack ছিল, যা assembly-তে একে একে বসাতে হতো। Cortex-M3 (২০০৪–০৫) এই অভ্যাস ভাঙে। টেবিলের প্রথম ঘর stack-এর শুরু, দ্বিতীয় ঘর reset handler-এর ঠিকানা, পরের ঘরগুলো বাকি exception-এর handler. Hardware প্রথম instruction-এর আগেই MSP বসায়, তাই reset handler একটি সাধারণ C function হতে পারে। এই পর্বের reference startup.c পুরোটা C, একটিও assembly লাইন ছাড়া; এর আসল build-এ প্রথম instruction movw r0, #8, কোনো SP সাজানো নেই।

দ্বিতীয় বদল হলো টেবিলে ঠিকানা থাকা, instruction নয়। পুরোনো ধরনে প্রতিটি interrupt-এর ঘরে একটি branch instruction বসাতে হতো, যার পরিসর সীমিত; Cortex-M-এ ঘরে সরাসরি ৩২-bit ঠিকানা, তাই handler flash-এর যেকোনো জায়গায় থাকতে পারে। আর VTOR থাকায় পুরো টেবিল সরানো যায়, যা bootloader আর application-এর আলাদা টেবিলকে সহজ করে।

মূল্যও আছে। টেবিলের প্রথম ঘর ভুল হলে (যেমন linker script-এ SRAM-এর মাপ ভুল) CPU প্রথম push-এই অবৈধ ঠিকানায় লেখে, আর বিষয়টি debugger ছাড়া বোঝা কঠিন। Reset vector-এর Thumb bit ভুলে গেলেও প্রথম instruction-এই fault. তবে এগুলো নির্মাণের ভুল, যা ELF থেকে টেবিল dump করে এক নজরে ধরা যায়, যেমন এই পর্বে 0x20005000 আর 0x08000359 দেখে।

মূল উপলব্ধি: SP আর handler-এর ঠিকানা hardware-এর টেবিলে তুলে দেওয়ায় startup থেকে interrupt পর্যন্ত সবকিছু C-তে লেখা সম্ভব হলো; বিনিময়ে টেবিলের শুদ্ধতাই boot-এর প্রথম শর্ত।

প্র ০২.bss শূন্য করার দায়িত্ব PC-তে কার, microcontroller-এ কার? Flash-এ শূন্যগুলো রেখে কপি করলেই তো একটি loop কম লাগত — কেন তা করা হয় না?

C মানদণ্ড বলে, static storage-এর যে object-এর কোনো প্রাথমিক মান দেওয়া হয়নি, তা শূন্য দিয়ে শুরু হবে (C11 §6.7.9). প্রোগ্রামার তাই int32_t tare_g; লিখে ধরে নেন tare শূন্য। প্রশ্ন হলো, প্রতিশ্রুতিটি রাখে কে।

PC-তে এই কাজ ভাগ করে OS আর loader. ELF ফাইলে .bss-এর শুধু মাপ লেখা থাকে, কোনো byte নয়; loader প্রোগ্রামের জন্য মেমরির page দেয়, আর OS নিরাপত্তার কারণেই নতুন page শূন্য করে দেয়, যাতে আগের প্রোগ্রামের গোপন তথ্য না দেখা যায়। ফলে .bss বিনামূল্যে শূন্য পাওয়া যায়। এর বিস্তারিত PLC কোর্সের linking আর loading পর্বে।

Microcontroller-এ loader নেই, OS নেই, আর SRAM-এর মান reset-এর পরে নিশ্চিত নয়। BG-M3-এ power-on-এ SRAM শূন্য, কিন্তু software আর watchdog reset-এ আগের মান থাকে (Spec decision 18); আসল chip-এ power-on-এর মানও নিশ্চিত নয়। তাই দায়িত্বটি startup code-এর। এই পর্বের ভাঙা startup দেখিয়েছে, দায়িত্ব না নিলে প্রথম boot-এ সব ঠিক দেখায় আর software reset-এর পরে দাম 91.70-এর বদলে 81.88 টাকা আসে।

Flash-এ শূন্য রাখার বিকল্পটি সম্ভব, কিন্তু অপচয়। একটি firmware-এ কয়েক KB-এর buffer থাকা স্বাভাবিক, যেমন UART-এর ring buffer বা sensor-এর নমুনা; এর প্রতিটি byte flash-এ শূন্য হিসেবে রাখলে flash-এর জায়গা আর programming-এর সময় দুটিই বাড়ে। শূন্য করার loop-এর খরচ স্থির: এই পর্বের build-এ 52 byte code, আর প্রতি word-এ তিনটি instruction. 1000 word-এর .bss নিয়ে আলাদা একটি build-এ bl main এসেছে ৩০১৪তম instruction-এ, অর্থাৎ board-এর মডেলে আধা millisecond-এরও কম। তাই linker .bss-কে NOLOAD রাখে: শুধু শুরু আর শেষের ঠিকানা।

মূল উপলব্ধি: C-এর “শূন্য দিয়ে শুরু” প্রতিশ্রুতি PC-তে OS রাখে, bare-metal-এ startup code; flash-এর জায়গা বাঁচাতে শূন্যগুলো জমা না রেখে প্রতি boot-এ লেখা হয়।

প্র ০৩Embedded firmware-এ main() ফিরলে কী হওয়া উচিত — অসীম loop, reset, না ঘুম? বাজারঘরের ঠান্ডা ঘরের monitor-এর জন্য কোনটি নিরাপদ?

Hosted C-তে main থেকে ফেরা মানে exit() ডাকা: buffer খালি করা, ফাইল বন্ধ করা, OS-কে ফলাফল জানানো। Freestanding পরিবেশে C মানদণ্ড এ বিষয়ে চুপ (C11 §5.1.2.1), তাই প্রতিটি startup নিজের উত্তর দেয়। কিছু GCC-ভিত্তিক toolchain-এর startup main-এর পরে library-র exit ডাকে, যা শেষে একটি অসীম loop বা debugger-এর কাছে বার্তা; reference lab-এর startup সরাসরি for (;;) { }.

এই পর্বে দুটি আসল উত্তর দেখা গেছে। Loop থাকলে CPU 0x080003D8-এ নিজের দিকে লাফাতে থাকে, board শেষে cycle limit-এ থামে। Loop না থাকলে compiler main-কে tail call করে, আর main ফেরে LR-এর reset মান 0xFFFFFFFF-এ; board তখন run থামায়, আর আসল Cortex-M3 সাধারণত fault-এ যায়। দ্বিতীয়টি অন্তত শব্দ করে; প্রথমটি নীরব।

নকশার বিকল্প তিনটি। (১) অসীম loop: সহজ, debugger দিয়ে ধরা যায়, কিন্তু মাঠে যন্ত্র “জীবিত দেখায় অথচ কাজ করে না”। (২) Reset: SCB->AIRCR-এ SYSRESETREQ, বা watchdog-কে আর না খাওয়ানো; যন্ত্র নিজে আবার শুরু করে, আর .noinit-এ একটি কারণ-চিহ্ন রেখে যাওয়া যায়। (৩) নিরাপদ অবস্থা আর ঘুম: output বন্ধ, alarm চালু, তারপর WFI; ব্যাটারির যন্ত্রে উপযোগী।

ঠান্ডা ঘরের monitor-এর কাজ 8.00 °C-এর ওপরে উঠলে alarm দেওয়া। নীরব অসীম loop এখানে সবচেয়ে খারাপ, কারণ তাপমাত্রা বাড়লেও কেউ জানবে না। তাই সাধারণ নীতি: main কখনো ফিরবে না (super loop বা RTOS), আর যদি কোনো ভুলে ফেরে, startup সেটিকে একটি ত্রুটি হিসেবে ধরবে; watchdog চালু থাকলে loop-ই শেষে reset ঘটাবে (reference-এর watchdog উদাহরণে 100 ms-এ reset). Reset-এর পরে .noinit-এর counter দেখে firmware চাইলে বার্তা পাঠাতে পারে, “আমি অপ্রত্যাশিতভাবে আবার চালু হলাম”।

মূল উপলব্ধি: main-এর পরের আচরণ startup code-এর একটি নকশা-সিদ্ধান্ত; নিরাপত্তা-সংক্রান্ত যন্ত্রে নীরবে আটকে থাকার চেয়ে ত্রুটি চিহ্নিত করে reset অনেক ভালো।

প্র ০৪Chip-এর ভেতরের ROM bootloader থাকতেও অনেক পণ্য নিজের bootloader লেখে কেন? নিজের bootloader-এর সবচেয়ে বড় ঝুঁকিগুলো কী?

ROM bootloader নির্মাতার দেওয়া, মোছা যায় না, তাই সবচেয়ে নির্ভরযোগ্য উদ্ধারকারী। উদাহরণ হিসেবে STM32F103-এর system memory-র bootloader BOOT pin বদলে UART দিয়ে firmware নেয়; RP2040-এর boot ROM BOOTSEL চেপে USB drive হয়ে দেখা দেয়; ESP32-এর ROM strapping pin দেখে download mode-এ যায়। কারখানায় প্রথম firmware বসাতে বা ভেঙে যাওয়া যন্ত্র উদ্ধারে এগুলো চমৎকার।

কিন্তু মাঠের যন্ত্রে এদের সীমা আছে। BOOT pin বদলাতে সাধারণত কাউকে যন্ত্র খুলে বোতাম চাপতে বা তার জুড়তে হয়; বাজারঘরের ঠান্ডা ঘরের ভেতরের monitor-এ প্রতিবার তা অবাস্তব। ROM bootloader নিজের পছন্দের পথ (Wi-Fi, MQTT, নির্দিষ্ট কোনো সার্ভার) জানে না, আর পণ্যের নিজস্ব যাচাইয়ের নিয়মও জানে না। তাই পণ্য নিজের bootloader রাখে: network থেকে নতুন image আনে, পরীক্ষা করে, flash-এ লেখে, তারপর এই পর্বের মতো VTOR আর MSP বসিয়ে application-এ লাফ দেয়।

ঝুঁকি তিন রকম। প্রথমত, update-এর মাঝপথে বিদ্যুৎ চলে যাওয়া (load-shedding-এর দেশে খুবই বাস্তব)। অর্ধেক লেখা application-এ লাফ দিলে যন্ত্র অচল; তাই CRC বা hash দিয়ে image যাচাই, অনেক নকশায় দুটি slot (A/B) রেখে পুরোনো ভালো image ফেরত রাখা। দ্বিতীয়ত, bootloader নিজেই নষ্ট হওয়া: তখন উদ্ধারের পথ শুধু ROM bootloader বা debugger, তাই bootloader-কে সাধারণত update করা হয় না বা খুব সাবধানে করা হয়। তৃতীয়ত, নিরাপত্তা: এই পর্বের তিন শর্ত শুধু ভুল ধরে, জাল নয়; কেউ নিজের firmware বসাতে পারলে যন্ত্র তার। এর উত্তর ডিজিটাল signature আর rollback-রোধ, যা পর্ব ৭৭-এর বিষয়।

আরেকটি ছোট কিন্তু পরিচিত ঝুঁকি হলো bootloader-এর রেখে যাওয়া অবস্থা। এই পর্বের নমুনায় bootloader interrupt বন্ধ করে আর SysTick থামিয়ে লাফ দেয়, আর application প্রথমেই interrupt চালু করে; কোনো পক্ষ এই চুক্তি না মানলে application-এর প্রথম interrupt ভুল জায়গায় যেতে পারে।

মূল উপলব্ধি: ROM bootloader উদ্ধারের জন্য, নিজের bootloader মাঠের update-এর জন্য; দ্বিতীয়টির নকশায় বিদ্যুৎ-বিভ্রাট, নিজের নষ্ট হওয়া আর জাল firmware তিনটিই ভাবতে হয়।

প্র ০৫.noinit section-এর ডেটা reset-এর পরে টিকে থাকে। এটি কখন উপকারী, কখন বিপজ্জনক, আর কীভাবে নিরাপদে ব্যবহার করবেন?

Reference linker script-এ .noinit একটি NOLOAD section, যাকে startup code কপিও করে না, শূন্যও করে না। BG-M3-এ SRAM software আর watchdog reset-এ টিকে থাকে (Spec decision 18), তাই এখানে রাখা মান reset পেরিয়ে যায়। এই পর্বের boot_demo-র boot_no এভাবেই 1 থেকে 2 হয়েছে, আর reference lab-এর watchdog উদাহরণ এভাবেই “boot #2, reset cause: WATCHDOG” ছাপে।

উপকার স্পষ্ট। কতবার অপ্রত্যাশিত reset হলো, শেষ HardFault-এ PC কত ছিল, crash-এর আগে কোন অবস্থায় ছিল: এমন তথ্য reset-এর পরে পাঠিয়ে মাঠের সমস্যা খোঁজা যায়। Bootloader আর application-এর মধ্যে বার্তা দেওয়াতেও এটি কাজে লাগে, যেমন “পরের boot-এ update mode-এ থাকতে হবে”।

বিপদও স্পষ্ট। প্রথম power-on-এ এই মেমরিতে কী আছে, তা জানা নেই; আসল chip-এ তা যেকোনো কিছু হতে পারে। তাই একটি counter-কে অন্ধভাবে বিশ্বাস করা যায় না। Reference-এর watchdog উদাহরণ একটি magic number (0xB00710AD) দিয়ে এটি সামলায়: মান না মিললে ধরে নেয় এটি নতুন power-on, আর সব নতুন করে বসায়। এই পর্বের boot_demo reset-কারণ register-এর POR flag দেখে একই কাজ করে। আরও সতর্ক নকশায় একটি CRC বা উল্টো-কপি রাখা হয়।

দ্বিতীয় বিপদ নির্মাণের: linker script-এ .noinit-কে .bss-এর ভেতরে ফেলে দিলে বা startup-এর loop-এর সীমায় off-by-one থাকলে এটি নীরবে মুছে যায়। এই পর্বের build-এ _ebss = 0x2000001C, আর ঠিক সেখানেই boot_no; loop-এ <= লিখলে counter প্রতিবার শূন্য হতো। তৃতীয়ত, কিছু chip-এ reset-এর ধরনভেদে (যেমন brown-out বা গভীর ঘুম থেকে জাগা) SRAM-এর কিছু অংশ মুছে যেতে পারে; সেটি chip-এর নথিতে দেখতে হয়।

মূল উপলব্ধি: .noinit reset পেরিয়ে স্মৃতি রাখার হাতিয়ার, কিন্তু তার মান প্রমাণ (magic বা CRC) ছাড়া বিশ্বাস করা যায় না, আর linker script ও startup-এর সীমা একে রক্ষা করছে কি না map file-এ দেখতে হয়।

অনুশীলন

প্রথমে নিজে লিখুন বা হিসাব করুন, তারপর উত্তর খুলুন। সংখ্যাগুলো আসল build আর run থেকে নেওয়া।

  1. নকশা: bootloader-এর যাচাই আর লাফ। একটি function void boot_app(uint32_t base) লিখুন, যা base-এ রাখা application-এর vector table যাচাই করে (SP SRAM-এর ভেতরে, reset-এর Thumb bit, reset-এর ঠিকানা application-অংশে) আর বৈধ হলে নিরাপদে লাফ দেয়। ধাপগুলোর ক্রম কেন গুরুত্বপূর্ণ, এক লাইনে বলুন।
    void boot_app(uint32_t base)
    {
        const uint32_t *v = (const uint32_t *)base;
        uint32_t sp = v[0], rv = v[1];
        if (sp < 0x20000000u || sp > 0x20005000u) return;     /* SP SRAM-এ */
        if ((rv & 1u) == 0u) return;                           /* Thumb bit */
        if (rv < base || rv >= 0x08020000u) return;            /* app-অংশে  */
        __disable_irq();                  /* ১. interrupt বন্ধ          */
        SysTick->CTRL = 0;                /* ২. bootloader-এর timer থামা */
        SCB->VTOR = base;                 /* ৩. app-এর টেবিল            */
        __asm volatile ("msr msp, %0\n\tbx %1" :: "r"(sp), "r"(rv) : "memory");
    }

    ক্রম কেন: VTOR বদলানোর আগে interrupt বন্ধ না করলে মাঝপথে একটি interrupt app-এর handler-এ যেতে পারে যখন app-এর stack বা ডেটা প্রস্তুত নয়; আর MSP বদলানোর পরে C কোড চালানো ঝুঁকিপূর্ণ (compiler পুরোনো stack-এ কিছু রাখতে পারে), তাই MSP আর লাফ এক inline assembly-তে। এই পর্বের bl.elf ঠিক এই ক্রমে চলেছে, আর app-এর প্রথম কাজ cpsie i. base ১২৮ byte-এ সাজানো হতে হবে (0x08004000 ঠিক আছে)।

  2. ভুল খুঁজুন। একজন startup-এ লিখলেন:
        for (dst = &_sbss; dst <= &_ebss; )
            *dst++ = 0;
    ...
    const vector_t g_vectors[] = {
        (vector_t)&_estack,
        (vector_t)((uint32_t)Reset_Handler & ~1u),   /* "ঠিকানা পরিষ্কার" */
    boot_demo-র build-এ _sbss = 0x20000008, _ebss = 0x2000001C, আর .noinit-এর boot_no 0x2000001C-এ। দুটি ভুল আর তাদের ফল লিখুন।

    ভুল ১ — <=: _ebss হলো .bss-এর শেষের পরের ঠিকানা। <= দিলে loop ৫টির বদলে ৬টি word লেখে, আর ষষ্ঠটি 0x2000001C = boot_no. ফলে reset-এর পরে টিকে থাকার কথা যে counter, প্রতি boot-এ শূন্য হয়; boot_demo প্রতিবার “boot #1” ছাপবে। অন্য build-এ এই জায়গায় অন্য variable বা stack থাকতে পারে। ঠিক: dst < &_ebss.

    ভুল ২ — Thumb bit মুছে ফেলা: reset vector-এর bit 0 EPSR-এর T bit-এ যায়। 0x08000358 দিলে T = 0, আর Cortex-M Thumb ছাড়া কিছু চালাতে পারে না, তাই ARMv7-M অনুযায়ী প্রথম instruction-এই fault (UsageFault, যা reset-এর ঠিক পরে HardFault হিসেবে আসে)। Linker নিজেই ঠিক মান 0x08000359 দেয়; শুধু Reset_Handler লিখলেই হয়। মনে রাখবেন, BG-M3 board PC বসানোর সময় bit 0 বাদ দেয় বলে এই ভুল board-এ ধরা না-ও পড়তে পারে; তাই ELF থেকে টেবিল dump করে দেখাই নিরাপদ।

  3. Trace আর আউটপুট অনুমান করুন। _sdata = 0x20000000, _edata = 0x20000008, _sbss = 0x20000008, _ebss = 0x2000001C. (ক) কয়টি word কপি আর কয়টি শূন্য হয়? (খ) .bss loop শেষে r1 কত? (গ) .bss loop মুছে দেওয়া startup-এ, boot #1-এ tare = 150 g বসিয়ে software reset করলে boot #2-এ 1400 g-এর জন্য UART-এ দাম কত দেখাবে (rate 6550 paisa/kg)?
    1. (ক) কপি: (0x20000008 − 0x20000000) ÷ 4 = 8 ÷ 4 = ২টি word (6550 আর 5000). শূন্য: (0x2000001C − 0x20000008) ÷ 4 = 0x14 ÷ 4 = 20 ÷ 4 = ৫টি word.
    2. (খ) প্রতি str-এ r1 += 4, পাঁচবারে 0x20000008 + 20 = 0x2000001C = _ebss; তখন bhs লাফ দেয়।
    3. (গ) .bss শূন্য না হওয়ায় tare 150 থেকে যায়: net = 1400 − 150 = 1250 g; দাম = (1250 × 6550 + 500) ÷ 1000 = 8188000 ÷ 1000 = 8188 paisa = 81.88 Tk. সঠিক startup-এ 91.70 Tk.

    যাচাই: board-এর আসল run-এ ঠিক এই লাইন এসেছে: 1400 g on the scale -> net=1250 g price=81.88 Tk, আর tracer-এ loop-এর শেষে r1=2000001C.

  4. হিসাব: startup-এর খরচ। Clang-এর build-এ .bss loop-এর প্রস্তুতি ৭টি instruction, তারপর প্রতি word-এ ৩টি (str, cmp, branch). .data খালি হলে তার অংশে ৬টি instruction, তারপর একটি bl main. (ক) 1000 word-এর .bss আর খালি .data-য় bl main কততম instruction? (খ) BG-M3-এর মডেলে (১ instruction = ১ cycle, 8 MHz) তা কত সময়? (গ) এই সংখ্যা আসল Cortex-M3-এর boot-সময় বলে কি?
    1. (ক) .data অংশ ৬ + .bss প্রস্তুতি ৭ + 1000 × 3 = 3000, মোট 3013টি instruction; তারপর bl main ৩০১৪তম।
    2. (খ) 3014 cycle ÷ 8 MHz = 3014 × 0.125 µs = 376.75 µs ≈ 0.377 ms.
    3. (গ) না। BG-M3 প্রতিটি instruction-কে এক cycle ধরে (Spec decision 17); আসল chip-এ store, branch আর flash-এর wait state মিলিয়ে cycle বেশি হতে পারে, আর reset-এর পরের clock সাধারণত ধীর ভেতরের oscillator. আসল সময় datasheet আর মাপ থেকে।

    যাচাই: int32_t big[1000]; নিয়ে আলাদা একটি firmware build করে tracer চালানো হয়েছে; bl main এসেছে ঠিক ৩০১৪তম instruction-এ। boot_demo-র ৫ word-এ একই সূত্র: ১৬ (.data-র ২ word সহ) + ৭ + ১৫ = ৩৮, তারপর ৩৯তম bl main, যা stepper-এর সঙ্গে মেলে।

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

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

ক্রমএকটি Cortex-M microcontroller-এ reset-এর পর থেকে main শুরু হওয়া পর্যন্ত ঘটনাগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. Vector table-এর word 0 থেকে MSP বসে
  2. Word 1 থেকে PC আর Thumb bit, Reset_Handler শুরু
  3. .data-র প্রাথমিক মান flash থেকে SRAM-এ কপি
  4. .bss শূন্য দিয়ে ভরা
  5. bl main দিয়ে main শুরু

একটি Cortex-M firmware-এর vector table-এর প্রথম দুটি word 0x20005000 আর 0x08000359. Reset-এর পরে MSP আর PC কত হবে?

  • MSP = 0x08000359, PC = 0x20005000
  • MSP = 0x20005000, PC = 0x08000359
  • MSP = 0x20005000, PC = 0x08000358
  • MSP = 0, PC = 0x00000000

C-তে int32_t tare_g; (প্রাথমিক মান ছাড়া global) লিখলে variable-টি কোন section-এ যায়, আর bare-metal-এ কে একে শূন্য করে?

  • .data; startup code flash থেকে শূন্য কপি করে
  • .bss; startup code-এর একটি loop শূন্য লেখে
  • .bss; OS-এর loader শূন্য করে
  • .rodata; SRAM নিজে থেকেই শূন্য থাকে

একটি startup code-এ .bss শূন্য করার loop নেই। Power-on-এ সব ঠিক চলে, কিন্তু software reset-এর পরে একটি ওজনযন্ত্রের tare আগের মান (150 g) রেখে দেয়। এর মূল কারণ কী?

  • Flash-এ tare-এর মান 150 লেখা আছে
  • .data-র কপি loop ভুল ঠিকানায় লিখছে
  • Software reset VTOR বদলে দেয়
  • Reset-এ SRAM আগের মান রাখে, আর কেউ .bss শূন্য করেনি

ARMv7-M reset-এ LR-কে 0xFFFFFFFF রাখে। Reset_Handler-এ main()-এর পরে অসীম loop না থাকলে আর main ফিরলে কী ঘটে?

  • CPU একটি অবৈধ ঠিকানায় ফিরতে চায় আর fault হয়
  • CPU স্বয়ংক্রিয়ভাবে main আবার শুরু করে
  • OS প্রোগ্রাম বন্ধ করে দেয়
  • Chip সঙ্গে সঙ্গে নিজে reset হয়

একটি bootloader application-এ লাফ দেওয়ার আগে SCB->VTOR-এ application-এর টেবিলের ঠিকানা (যেমন 0x08004000) লেখে। এর উদ্দেশ্য কী?

  • Application-এর code-কে 0x08000000-এ সরিয়ে আনা
  • পরের সব exception যেন application-এর নিজের handler-এ যায়
  • MSP স্বয়ংক্রিয়ভাবে application-এর মানে বসানো
  • Chip-কে reset করে application চালু করা

Reset-এর পরে Intel 8086 প্রথম instruction কোন physical address থেকে আনে?

  • 00000H
  • FFFFFH
  • FFFF0H
  • 0x08000000

শব্দকোষ

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

মনে রাখুন

  1. দুটি word দিয়ে শুরু: vector table-এর word 0 → MSP, word 1 → PC আর Thumb bit (bit 0); LR = 0xFFFFFFFF.
  2. Reset_Handler-এর তিন কাজ: .data কপি (flash → SRAM), .bss শূন্য, main; boot_demo-য় bl main ৩৯তম instruction.
  3. .bss-এর bug লুকিয়ে থাকে: power-on-এ ঠিক, software reset-এর পরে tare 150 g থেকে যায় আর দাম 81.88 টাকা।
  4. main ফেরে না: startup-এর অসীম loop শেষ রক্ষা; loop না থাকলে LR-এর 0xFFFFFFFF-এ লাফ আর fault.
  5. Bootloader-এর লাফ: যাচাই → interrupt বন্ধ → VTOR → MSP → reset vector-এ bx; টেবিল ১২৮ byte-এ সাজানো।

পরের পর্বে: Board এতক্ষণ স্থির 8 MHz-এ চলেছে। আসল chip-এ reset-এর পরে ধীর ভেতরের oscillator, তারপর crystal আর PLL দিয়ে 72 MHz; সঙ্গে reset-এর কারণ পড়া আর brown-out, সেটি পর্ব ৩৩-এ (Clock, reset আর power domain — PLL, clock tree আর brown-out).

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

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