এই পর্বে যা শিখবেন
- Bare-metal, RTOS আর embedded Linux-এর গঠন, খরচ আর সীমা পাশাপাশি তুলনা করা
- Linux কেন MMU চায়, আর microcontroller বনাম application processor-এর পার্থক্য কাজের ভাষায় বলা
- MCU-র reset থেকে
main()আর Linux-এর boot-এর প্রতিটি ধাপ চিনে নেওয়া - Device tree, driver, kernel space আর user space দিয়ে Linux-এ একটি GPIO-র পথ বোঝা
- Latency-র সংখ্যা উৎসসহ পড়ে একটি যন্ত্রের জন্য যুক্তি দিয়ে পথ বাছাই করা
১ · তিনটি পথ — bare-metal, RTOS আর embedded Linux
মডিউল ৯-এর আগের পর্বগুলোতে আপনি সময়ের হিসাব (পর্ব ৫৪), RTOS ছাড়া super loop আর state machine (পর্ব ৫৫), RTOS-এর task ও scheduling (পর্ব ৫৬), synchronization (পর্ব ৫৭) আর queue ও বার্তা (পর্ব ৫৮) দেখেছেন। এই পর্ব মডিউলের শেষ ধাপ: তিনটি পথ পাশাপাশি রেখে প্রশ্ন করা, কোন যন্ত্রে কোনটি। এই পর্বে hex লেখা হবে C-ধাঁচে, 0x….
Bare-metal মানে কোনো অপারেটিং সিস্টেম নেই: আপনার main(), কয়েকটি ISR আর peripheral register, ব্যস। RTOS একটি ছোট kernel যোগ করে, যা কয়েকটি task-কে priority অনুযায়ী CPU দেয়, আর queue, semaphore দিয়ে তাদের কথা বলায়। Embedded Linux মানে desktop-এর মতোই Linux kernel, তবে যন্ত্রের মাপে ছেঁটে বানানো: process, file system, network stack, হাজারো driver, আর তার ওপর সাধারণ program.
উপমা — চায়ের দোকান, রেস্তোরাঁ আর হোটেল: মোড়ের চায়ের দোকানে একজন মানুষ সব করেন: কেতলি দেখেন, কাপ ধোন, টাকা নেন। কাজ কম আর পরিচিত, তাই কোনো ব্যবস্থাপক লাগে না: এটি bare-metal. একটি ব্যস্ত রেস্তোরাঁয় কয়েকজন রাঁধুনি আর একজন ব্যবস্থাপক, যিনি ঠিক করেন কোন অর্ডার আগে: এটি RTOS. আর একটি বড় হোটেলে আলাদা বিভাগ, অভ্যর্থনা, নিরাপত্তা, হিসাবরক্ষণ, নিয়মের খাতা: অনেক কাজ একসাথে, প্রতিটি নিজের ঘরে আটকানো, কিন্তু কোনো একটি কাপ চা ঠিক কত সেকেন্ডে আসবে, সেই প্রতিশ্রুতি দেওয়া কঠিন। এটি Linux.
ছবি ৫৯.১ — তিন পথের স্তর: নিচে hardware, ওপরে আপনার কোড
যত ওপরে স্তর, তত সুবিধা; যত স্তর, তত মেমরি আর সময়ের অনিশ্চয়তা
| বিষয় | Bare-metal | RTOS | Embedded Linux |
|---|---|---|---|
| সাধারণ hardware | MCU (Cortex-M, AVR) | MCU | MMU-সহ application processor, বাইরে DRAM |
| OS-এর নিজের মাপ | শূন্য | FreeRTOS-এর kernel image সাধারণত 4000–9000 byte (AWS-এর নথি) | MB-এর ঘরে: kernel, library, root file system |
| চালু হতে | µs থেকে ms | µs থেকে ms | সাধারণত সেকেন্ডের ঘরে; ছোট করা যায়, শূন্য নয় |
| সময়ের নিশ্চয়তা | সবচেয়ে সরল প্রমাণ | priority আর analysis দিয়ে প্রমাণযোগ্য | মাপা যায়, প্রমাণ কঠিন; PREEMPT_RT অনেক উন্নত করে |
| Network, file system, নানা program | সব নিজে | library যোগ করে (যেমন TCP/IP stack) | তৈরি, বছরের পর বছর পরীক্ষিত |
| একটি program-এর ভুল | পুরো যন্ত্র পড়ে যায় | বেশিরভাগ ক্ষেত্রে পুরো যন্ত্র (MPU না থাকলে) | শুধু সেই process মারা যায়, বাকি চলে |
টেবিলের প্রতিটি সারি একটি দাম আর একটি সুবিধা। Linux সবচেয়ে বেশি দেয়, কিন্তু সবচেয়ে বেশি চায়: বড় chip, বাইরের মেমরি, বেশি বিদ্যুৎ, দীর্ঘ boot, আর বছরের পর বছর security update. Bare-metal সবচেয়ে কম চায়, কিন্তু প্রতিটি সুবিধা নিজে লিখতে হয়। একই OS-এর প্রশ্ন OS-এর দৃষ্টিতে Operating Systems পর্ব ৫৪-এ আলোচিত; এখানে আমরা firmware নকশাকারের চোখে দেখব।
মূল নিয়ম OS বাছাই শুরু হয় প্রয়োজনের তালিকা থেকে, পছন্দের OS থেকে নয়। “Linux জানি, তাই Linux” বা “RTOS আধুনিক, তাই RTOS” দুটিই ভুল প্রশ্ন।
২ · Linux কেন MMU চায় — microcontroller বনাম application processor
সাধারণ Linux প্রতিটি process-কে একটি নিজস্ব ঠিকানা-জগৎ দেয়, যার নাম virtual memory. দুটি program একই ঠিকানা 0x10000 ব্যবহার করলেও তারা আলাদা physical RAM-এ পৌঁছায়, কারণ CPU-র MMU প্রতিটি load আর store-এ ঠিকানা অনুবাদ করে আর অনুমতি যাচাই করে। এই ব্যবস্থার ওপর দাঁড়িয়ে Linux-এর তিনটি মৌলিক সুবিধা: একটি process অন্যের মেমরি ছুঁতে পারে না, kernel-এর মেমরি সাধারণ program থেকে সুরক্ষিত, আর fork() একটি process-এর হুবহু কপি সস্তায় বানায়। কীভাবে, তার পুরো ব্যাখ্যা Operating Systems পর্ব ৩৫-এ।
Cortex-M-এ MMU নেই (পর্ব ০৩). অনেক Cortex-M chip-এ ঐচ্ছিক একটি MPU থাকে, যা কয়েকটি এলাকার অনুমতি পাহারা দেয়, কিন্তু ঠিকানা অনুবাদ করে না। তাই সাধারণ Linux চলে Cortex-A পরিবারের মতো application processor-এ: MMU, cache, প্রায়ই একাধিক core, আর বাইরে MB থেকে GB মাপের DRAM. ARM-এর নামকরণেই ভাগটি স্পষ্ট: Cortex-A (application), Cortex-R (real-time), Cortex-M (microcontroller).
Microcontroller (এই কোর্সের board)
Flash আর SRAM chip-এর ভেতরে; বাজারঘর board-এ 128 KiB flash আর 20 KiB SRAM (Spec decision 18). ঠিকানা = physical ঠিকানা: 0x40010810 লিখলে সরাসরি GPIOA-র BSRR register. বিদ্যুৎ দিলে কয়েক cycle-এ কোড চলে।
Application processor (gateway)
DRAM বাইরে, program থাকে storage-এ (eMMC, SD card, NAND). প্রতিটি program virtual ঠিকানায় চলে; register-এর physical ঠিকানা শুধু kernel-এর driver জানে, নিজের virtual ঠিকানায় map করে।
MMU ছাড়া Linux? আছে, সীমিত রূপে। Linux kernel-এ কয়েকটি architecture-এর জন্য MMU-হীন (CONFIG_MMU=n) কনফিগারেশন আছে, যা একসময় uClinux নামে আলাদা প্রকল্প ছিল; কিছু Cortex-M chip-এও এভাবে Linux চালানোর উদাহরণ আছে। কিন্তু সেখানে process-এর মধ্যে সুরক্ষা নেই, fork() নেই (শুধু vfork()), আর মেমরির খণ্ডিত হওয়া বড় সমস্যা। তাই বাস্তবে MCU-তে প্রায় সবসময় bare-metal বা RTOS, আর Linux-এর জন্য MMU-সহ chip বেছে নেওয়া হয়।
৩ · Boot — MCU-র reset বনাম Linux-এর ধাপ
MCU-র boot আপনি পর্ব ৩২-এ খুঁটিয়ে দেখেছেন: reset-এ CPU vector table থেকে MSP আর PC নেয় (বাজারঘর board-এ 0x08000000 আর 0x08000004, Spec decision 18), startup code .data কপি করে আর .bss শূন্য করে, তারপর main(). কত দ্রুত? আমার lab-এ একটি firmware, যার main()-এর প্রথম কাজ board-এর MARK register-এ লেখা (Spec decision 29):
/* tomain.c - how long from reset to the first line of main()? */
#include "bazarghar.h"
int main(void)
{
SIMCTRL->MARK = 1; /* first thing in main */
board_exit(0);
}সত্যিকারের run — board.py build/run (BG-M3, Clang 22.1.8 -O2); বাছাই করা লাইন
~/lab/_ref $ python -B board.py run ../elinux/build/tomain.elf --trace 40 --cycles 100
[ 0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[ 0.0001 ms] trace PC=0x08000078 Reset_Handler+0x0
... (Reset_Handler-এর আরও 12টি নির্দেশ)
[ 0.0018 ms] trace PC=0x08000060 main+0x0
[ 0.0021 ms] MARK 1
[ 0.0024 ms] exit(0) after 19 cycles
~/lab/_ref $ python -B board.py run ../elinux/build/tomain_bss.elf # .bss-এ 4096 byte
[ 0.3865 ms] MARK 1
[ 0.3869 ms] exit(0) after 3095 cycles
খালি firmware-এ Reset_Handler-এর 13টি নির্দেশের পরে main; board-এ 1 নির্দেশ = 1 cycle, তাই 8 MHz-এ প্রায় 1.6 µs. .bss-এ 4 KiB থাকলে শূন্য করার loop প্রতি word-এ ৩টি নির্দেশ নেয়, আর মোট 3095 cycle. Reference-এর smart scale-এর firmware তার প্রথম লাইন “scale ready” পাঠায় 0.0729 ms-এ। মনে রাখুন, এগুলো board-এর cycle: আসল chip-এ নির্দেশপ্রতি cycle আলাদা, আর তার আগে clock আর power স্থির হওয়ার সময় যোগ হয়, যা datasheet থেকে আসে (Spec decision 17).
Linux-এর boot অনেক লম্বা পথ, কারণ চালু হওয়ার আগে DRAM জাগাতে হয়, বড় kernel storage থেকে আনতে হয়, আর হাজারো driver-কে hardware চিনতে হয়। ARM-ভিত্তিক বহু board-এ সাধারণ ক্রম নিচের stepper-এ; PC-র BIOS/UEFI আর GRUB-এর দিকটি Operating Systems পর্ব ০৭-এ।
| ধাপ | |
| MCU\n(board run) | |
| Linux SoC | |
| কোথায় কোড |
- Reset. MCU vector table-এর প্রথম দুই word থেকে stack pointer আর Reset_Handler-এর ঠিকানা নেয়। SoC-এ প্রথম চলে chip নির্মাতার Boot ROM, যা boot pin বা fuse দেখে ঠিক করে কোন storage থেকে পরের ধাপ পড়বে।
- প্রথম কোড। MCU-র startup code মেমরি গুছিয়ে নেয়। SoC-এ তখনো DRAM ঘুমিয়ে, তাই ছোট একটি প্রথম ধাপের loader (U-Boot-এর ক্ষেত্রে যার নাম SPL) chip-এর ভেতরের ছোট SRAM-এ চলে আর DRAM controller চালু করে।
- পরের ধাপ। MCU 13টি নির্দেশে
main()-এ। SoC-এ পূর্ণ bootloader (প্রায়ই U-Boot) DRAM-এ চলে, storage থেকে kernel image আর device tree-এর binary (DTB) আনে, তারপর kernel-এ লাফ দেয়। - প্রথম কাজ। Board-এ scale-এর firmware 0.0729 ms-এ প্রথম লাইন পাঠায়। Kernel তখন MMU চালু করে, DTB পড়ে জানে কোথায় কোন hardware, আর মিলে যাওয়া driver চালায়।
- ব্যবস্থা দাঁড়ানো। MCU-র আর কোনো ধাপ নেই। Kernel root file system mount করে (কখনো আগে একটি initramfs-এর সাহায্যে) আর প্রথম user-space program init চালায়, যার PID 1.
- আপনার program. Init (যেমন systemd বা BusyBox-এর init) service চালু করে, আর শেষে gateway-এর program. মোট সময় board, storage আর configuration অনুযায়ী অনেক বদলায়; প্রায়ই সেকেন্ডের ঘরে, যত্ন করে ছাঁটলে কম।
এই পার্থক্যের একটি ব্যবহারিক ফল আছে। Load-shedding-এর পরে বিদ্যুৎ ফিরলে MCU প্রায় সঙ্গে সঙ্গে আবার মাপতে শুরু করে, কিন্তু Linux gateway কয়েক সেকেন্ড বা তার বেশি অন্ধ থাকে। Cold room-এর alarm তাই gateway-এর ওপর নির্ভর করা চলবে না; সেটি MCU-তেই থাকবে।
৪ · একই C, দুই জগৎ — Linux-এর ELF বনাম bare-metal ELF
Linux-এর program-ও C-তে লেখা, আর একই Clang তাকে বানায়; বদলায় শুধু target (পর্ব ৩৭-এর cross-compiler). Gateway-এর জন্য একটি ছোট program, যা README-র সূত্রে 1250 g-এর দাম ছাপে:
/* gw.c - a tiny Linux user-space program for the warehouse gateway */
#include <stdio.h>
static unsigned price_paisa(unsigned net_g)
{
return (net_g * 6550u + 500u) / 1000u;
}
int main(void)
{
unsigned p = price_paisa(1250);
printf("gateway: 1250 g -> %u.%02u Tk\n", p / 100, p % 100);
return 0;
}এটি তিনটি Linux target-এর জন্য compile করা হলো, আর নিজের lab-এর ছোট stdlib-only ELF reader (elfpeek.py) দিয়ে পড়া হলো। পাশে তুলনার জন্য board-এর tomain.elf. কোনো Linux যন্ত্র এখানে নেই, তাই program চালানো হয়নি; শুধু তৈরি করা ফাইলের গঠন দেখা।
সত্যিকারের run — ziglang 0.17.1 (Clang 22.1.8); বাছাই করা লাইন
~/lab/lx $ python -m ziglang cc -target aarch64-linux-gnu -O2 -s -fno-sanitize=undefined -o gw_a64_dyn_s gw.c
~/lab/lx $ python -m ziglang cc -target aarch64-linux-musl -O2 -s -fno-sanitize=undefined -o gw_a64_static_s gw.c
~/lab $ python -B elfpeek.py lx/gw_a64_dyn_s
lx/gw_a64_dyn_s: 3480 bytes, ELF64, AArch64, type EXEC, entry 0x10104D8
interpreter: /lib/ld-linux-aarch64.so.1
needs: libc.so.6
.text addr 0x010104D8 size 216
~/lab $ python -B elfpeek.py lx/gw_a64_static_s
lx/gw_a64_static_s: 26192 bytes, ELF64, AArch64, type EXEC, entry 0x1011AE8
interpreter: none (static)
.text addr 0x01011AE8 size 18164
~/lab $ python -B elfpeek.py build/tomain.elf
build/tomain.elf: 5672 bytes, ELF32, ARM, type EXEC, entry 0x8000079
interpreter: none (static)
.isr_vector addr 0x08000000 size 96
.text addr 0x08000060 size 156
তিনটি জিনিস লক্ষ করুন। এক, Linux-এর dynamic program-এর .text মাত্র 216 byte, কারণ printf তার ভেতরে নেই: ফাইলটি বলে “/lib/ld-linux-aarch64.so.1 আমাকে চালাবে, আর libc.so.6 লাগবে”, এমন কথা। এই dynamic linker আর shared library gateway-এর root file system-এ থাকতে হবে। দুই, static build (musl libc) সব নিজের ভেতরে নেয়: .text 18164 byte, কিন্তু কিছুর ওপর নির্ভর করে না। তিন, ঠিকানা: Linux program-এর ঠিকানা 0x01… virtual, kernel আর MMU তাকে যেকোনো physical RAM-এ বসায়; board-এর firmware বসে ঠিক 0x08000000-এ, flash-এর physical ঠিকানায়, আর শুরুতে vector table. Linking আর loading-এর পুরো তত্ত্ব Programming Languages পর্ব ৭৪-এ।
Strip না করলে ভুল ছবি: একই static build -s ছাড়া 1444304 byte ছিল, যার 1398956 byte debug তথ্য (.debug_*), যন্ত্রে লোড হয় না। ফাইলের আকার আর যন্ত্রের মেমরির খরচ এক জিনিস নয়; section-এর মাপ দেখুন।
ELF-এর header নিজেই বলে দেয় ফাইলটি কোন জগতের। নিচের ব্লক তিনটি সত্যিকারের build-এর header-এর প্রথম byte (hex) থেকে class, machine, entry আর ARM-এর float ABI পড়ে:
# তিনটি সত্যিকারের build-এর ELF header-এর প্রথম byte-গুলো পড়া
import struct
files = { # Clang 22.1.8 (ziglang 0.17.1) দিয়ে বানানো, hex
"gateway, aarch64-linux-gnu": "7f454c460201010000000000000000000200b70001000000d804010100000000",
"gateway, arm-linux-musleabihf": "7f454c460101010000000000000000000200280001000000900e020034000000"
"0c1a120000040005",
"board, thumbv7m-none-eabi": "7f454c4601010100000000000000000002002800010000007900000834000000"
"9814000000020005",
}
MACH = {40: "ARM (32-bit)", 183: "AArch64 (64-bit)"}
for name, hx in files.items():
b = bytes.fromhex(hx)
assert b[:4] == b"\x7fELF"
bits = 64 if b[4] == 2 else 32
e_type, mach = struct.unpack_from("<HH", b, 16)
entry = struct.unpack_from("<Q" if bits == 64 else "<I", b, 24)[0]
print(f"{name}: ELF{bits}, {MACH[mach]}, type {e_type} (2 = EXEC)")
line = f" entry 0x{entry:08X}"
if bits == 32:
flags = struct.unpack_from("<I", b, 36)[0]
abi = "hard-float" if flags & 0x400 else "soft-float" if flags & 0x200 else "?"
line += f", e_flags 0x{flags:08X} ({abi})"
if entry & 1:
line += ", bit 0 = 1: Thumb"
print(line)আসল আউটপুট (ব্রাউজারের Python):
gateway, aarch64-linux-gnu: ELF64, AArch64 (64-bit), type 2 (2 = EXEC)
entry 0x010104D8
gateway, arm-linux-musleabihf: ELF32, ARM (32-bit), type 2 (2 = EXEC)
entry 0x00020E90, e_flags 0x05000400 (hard-float)
board, thumbv7m-none-eabi: ELF32, ARM (32-bit), type 2 (2 = EXEC)
entry 0x08000079, e_flags 0x05000200 (soft-float), bit 0 = 1: Thumb
৩২-bit ARM Linux আর board-এর firmware দুটিই “ARM”, তবু আলাদা জগৎ: Linux build-এ hard-float ABI (floating-point register-এ argument), board-এ soft-float (-mfloat-abi=soft, Cortex-M3-এ FPU নেই). Board-এর entry-র bit 0 = 1 মানে Thumb কোড, Cortex-M কেবল Thumb চালায় (পর্ব ২৯). ভুল target-এর ফাইল যন্ত্রে দিলে loader বা CPU এই header দেখেই আটকাবে, বা আরও খারাপ, ভুল ABI-তে চুপচাপ ভুল ফল দেবে।
৫ · Device tree, driver আর user space — Linux-এ একটি LED
Bare-metal-এ PA6-এর alarm চালু করা একটি লাইন: GPIOA->BSRR = 1u << 6; (পর্ব ৪১). Linux-এ একই কাজ তিন পক্ষের সহযোগিতায়, আর প্রতিটির আলাদা দায়িত্ব।
এক, device tree: hardware-এর বর্ণনা। MCU-তে register-এর ঠিকানা আপনার header-এ লেখা থাকে। Linux একই kernel বহু board-এ চালাতে চায়, তাই কোন ঠিকানায় কোন controller, কোন pin-এ কোন LED, সেই তথ্য আলাদা একটি লেখায় রাখে: device tree source (.dts), যা compile হয়ে DTB হয় আর bootloader kernel-কে দেয়। Kernel-এর gpio-leds binding অনুযায়ী একটি alarm LED আর একটি I2C তাপমাত্রা sensor-এর বর্ণনা এমন দেখায় (উদাহরণ, চালানো হয়নি; &gpio1 আর &i2c1-এর নাম board-এর মূল .dts-এ যেমন, তেমন হবে):
/ {
leds {
compatible = "gpio-leds";
led-0 {
gpios = <&gpio1 6 GPIO_ACTIVE_HIGH>; /* controller, pin, flag */
default-state = "off";
};
};
};
&i2c1 {
status = "okay";
temp-sensor@48 {
compatible = "ti,tmp102";
reg = <0x48>;
};
};compatible হলো মিলনের চাবি: kernel যে driver নিজেকে "ti,tmp102"-এর বলে ঘোষণা করে, তাকে এই node দেয়। বাজারঘরের cold room-এর sensor-ও TMP102-ধাঁচের, address 0x48 (README); MCU-তে reference coldroom.c নিজে I2C-তে register 0x00 পড়ে প্রতি LSB 0.0625 °C ধরে হিসাব করে (পর্ব ৫১); Linux-এ সেই কাজ driver করে।
দুই, driver: kernel-এর ভেতরে register ছোঁয়া। Driver kernel space-এ চলে, register-এর physical ঠিকানা নিজের virtual ঠিকানায় map করে, আর ফল একটি সাধারণ interface-এ দেয়। Kernel-এর ভেতরের গঠন Operating Systems পর্ব ৫৫-এ।
তিন, user space: আপনার program. User space-এর program register ছুঁতে পারে না, kernel-এর interface দিয়ে চায়। তাপমাত্রার sensor-এর জন্য hwmon-এর sysfs ফাইল, আর GPIO-র জন্য GPIO character device:
উদাহরণ, চালানো হয়নি (কোনো Linux board নেই; নাম আর সংখ্যা board-ভেদে আলাদা)
$ cat /sys/class/hwmon/hwmon0/temp1_input # millidegree Celsius
8250
$ gpioget -c gpiochip0 6 # libgpiod v2: chip আর line offset
$ gpioset -c gpiochip0 6=1 # line চেয়ে নিয়ে 1 রাখে, চলতে থাকে
দুটি সতর্কতা kernel আর libgpiod-এর নিজস্ব নথি থেকে। প্রথমত, পুরোনো পথ /sys/class/gpio/export (sysfs GPIO) kernel-এর নথিতে obsolete: নতুন কাজে GPIO character device API ব্যবহারের নির্দেশ, আর পুরোনো পথ শুধু স্থানান্তরের সময় পর্যন্ত রাখা হচ্ছে। এর সংখ্যাও pin-এর নাম নয়, একটি global GPIO নম্বর। দ্বিতীয়ত, libgpiod-এর gpioset line ধরে রাখে যতক্ষণ সে চলে; process শেষ হলে line ছেড়ে দেওয়া হয়, তখন pin-এর অবস্থা নিশ্চিত নয়। Bare-metal-এ আপনি লিখলেন তো লেখা থাকল; Linux-এ মালিকানা kernel-এর হিসাবে।
| স্তর | |
| MCU | |
| Linux | |
| ভুল হলে |
- আপনার কোড। MCU-তে একটি C লাইন, যা Clang একটি
strনির্দেশে বানায়। Linux-এ program আগে line-টি চেয়ে নেয় (request), তারপর মান লিখতে বলে; command line-এ এটিইgpiosetকরে। - Mode বদল। Bare-metal-এ সব কোড একই অধিকারে চলে। Linux-এ অনুরোধটি একটি system call: CPU user mode থেকে kernel mode-এ যায়। এই দেয়ালই একটি ভুল program-কে বাকি যন্ত্র থেকে আলাদা রাখে।
- Kernel-এর হিসাব। GPIO subsystem (gpiolib) দেখে line-টি কে চেয়েছে। অন্য program আগে থেকে ধরে থাকলে অনুরোধ বাতিল। MCU-তে এমন পাহারা নেই: দুটি কোড একই register-এ লিখলে শেষজনই জেতে।
- Driver-এর কাজ। Boot-এর সময় device tree-র
compatibleমিলিয়ে যে chip driver যুক্ত হয়েছিল, সে নিজের register-এ bit লেখে। Driver kernel-এর অংশ, তাই তার bug পুরো যন্ত্রকে ফেলে দিতে পারে। - ঠিকানা। MCU-তে
0x40010810সরাসরি GPIOA-র BSRR (board-এর মানচিত্র, README). Linux-এ driver register-কে virtual ঠিকানায় map করে লিখেছে, MMU তাকে physical ঠিকানায় অনুবাদ করে। - Pin বদলায়। ফল একই, LED জ্বলে। পার্থক্য পথের দৈর্ঘ্যে: MCU-তে একটি store, Linux-এ অনেক বেশি নির্দেশ, mode বদল আর scheduler-এর সিদ্ধান্ত। বদলে পাওয়া যায় সুরক্ষা, ভাগাভাগি আর একই program বহু board-এ চালানো।
৬ · সময়ের নিশ্চয়তা — determinism আর PREEMPT_RT
Real-time-এর প্রতিশ্রুতি গড়ের নয়, সবচেয়ে খারাপের (পর্ব ৫৪). Determinism মানে একই ঘটনায় প্রতিবার একই, বা জানা সীমার ভেতরে, সাড়া। Cortex-M-এ এটি সরল: ARM-এর Cortex-M3 Technical Reference Manual অনুযায়ী interrupt-এর অনুরোধ থেকে handler-এর প্রথম নির্দেশ পর্যন্ত 12 cycle (zero wait state মেমরিতে); তার সঙ্গে চলতি নির্দেশ শেষ করা, flash-এর wait state আর interrupt বন্ধ রাখা অংশ যোগ হয় (পর্ব ৪৩). প্রতিটি উপাদান হিসাবযোগ্য।
সাধারণ Linux-এর লক্ষ্য আলাদা: গড়ে ভালো throughput. Kernel-এর ভেতরে কিছু জায়গায় preemption বা interrupt কিছুক্ষণ বন্ধ থাকে, page fault আর cache-এর কারণে একই কোড আলাদা সময় নেয়, আর বহু program CPU-র জন্য প্রতিযোগিতা করে। PREEMPT_RT এই বন্ধ থাকার জায়গাগুলো ছোট করে: বেশিরভাগ spinlock-কে ঘুমাতে-পারা lock বানায়, interrupt handler-কে thread বানায় যাতে তাদেরও priority দেওয়া যায়, আর lock-এ priority inheritance, যার RTOS-এর রূপ পর্ব ৫৭-এর বিষয়। বহু বছর এটি আলাদা patch-গুচ্ছ ছিল; ২০২৪ সালের সেপ্টেম্বরে Linux 6.12-এর merge window-এ মূল kernel-এ ঢোকে, প্রথমে x86, arm64 আর RISC-V-তে, CONFIG_PREEMPT_RT অপশন হিসেবে। 6.12 প্রকাশ পায় নভেম্বর ২০২৪-এ। পরের সংস্করণে আরও architecture যোগের খবর আছে; আপনার chip-এর জন্য kernel-এর Kconfig মিলিয়ে দেখুন।
| কী | |
| মান | |
| উৎস | |
| রায় |
- Cortex-M3-এর সংখ্যা। ARM-এর নথি অনুযায়ী 12 cycle, যার মধ্যে আটটি register stack-এ রাখাও আছে (পর্ব ৩০). এটি সর্বনিম্ন; interrupt বন্ধ রাখা কোড বা উঁচু priority-র ISR চললে বাড়ে, কিন্তু প্রতিটি কারণ কোড পড়ে সীমিত করা যায়।
- Cycle থেকে সময়। 12 ÷ 8 MHz = 1.5 µs; 72 MHz-এ 0.167 µs. নিচের Python ব্লক একই হিসাব দেখায়।
- কোর্সের board-এর সংখ্যা আসল নয়। Board-এ exception-এ ঢোকা-ফেরা 0 cycle আর প্রতিটি নির্দেশ 1 cycle (Spec decision 17). Board-এ যুক্তি আর ক্রম যাচাই হয়, আসল chip-এর latency নয়।
- PREEMPT_RT. George K. Adam-এর ২০২১ সালের গবেষণাপত্র (Computers, MDPI) Raspberry Pi আর BeagleBoard-ধাঁচের board-এ মাপের ভিত্তিতে বলে, বেশিরভাগ ক্ষেত্রে সবচেয়ে খারাপ latency কয়েক দশ µs-এর ঘরে নেমেছে। সংখ্যাটি board, kernel, load আর মাপার পদ্ধতিভেদে বদলায়; নিজের hardware-এ
cyclictest-এর মতো tool দিয়ে মাপতে হয়। - সাধারণ Linux-এর অবস্থা। কোনো প্রকাশিত একক সংখ্যা এখানে দেওয়া হচ্ছে না, কারণ ফল configuration আর load অনুযায়ী অনেক বদলায়, আর মূল কথা হলো কোনো নিশ্চিত সীমার প্রতিশ্রুতি নেই। তাই hard deadline এর হাতে নয়।
- Deadline-এর পাশে। Cold room-এর alarm-এর বাজেট সেকেন্ডের (পর্ব ৫৪): যেকোনো পথ পারে। 115200 baud-এ একটি byte 86.8 µs-এ আসে: “কয়েক দশ µs”-এর ওপরের প্রান্ত এর কাছাকাছি, তাই Linux-এ UART-এর byte ধরে hardware FIFO আর DMA, software নয়। মাঝের কাজ (1 kHz loop) PREEMPT_RT-এ সম্ভব, মেপে নিশ্চিত হয়ে।
# সময়ের তুলনা: cycle -> µs, আর কোন deadline-এ কোন পথ চলে
def us(cycles, mhz):
return cycles / mhz
# ১) board-এ reset থেকে main (সত্যিকারের run, 1 নির্দেশ = 1 cycle)
runs = {0: 19, 1024: 3095, 2048: 6167} # .bss-এর word -> exit পর্যন্ত cycle
for words, cyc in runs.items():
print(f".bss {words * 4:5} byte: {cyc:5} cycle = {us(cyc, 8):7.3f} µs (board, 8 MHz)")
per_word = (runs[2048] - runs[1024]) / 1024
print(f"প্রতি word শূন্য করতে {per_word:.0f} cycle")
# ২) Cortex-M3: interrupt থেকে handler-এর প্রথম নির্দেশ 12 cycle (ARM, zero wait state)
for mhz in (8, 72):
print(f"Cortex-M3 @ {mhz:2} MHz: 12 cycle = {us(12, mhz):.3f} µs")
# ৩) deadline-গুলোর পাশে "কয়েক দশ µs" (PREEMPT_RT-এর প্রকাশিত মাপের ঘর)
deadlines = {"UART byte 115200": 10 / 115200 * 1e6,
"cold room alarm": 2e6,
"1 kHz loop": 1000.0}
for name, d in deadlines.items():
for lat in (10, 99): # "কয়েক দশ" ঘরের দুই প্রান্ত
print(f"{name:16} D={d:9.1f} µs, দেরি {lat:2} µs = D-এর {lat / d:.4%}")আসল আউটপুট (ব্রাউজারের Python):
.bss 0 byte: 19 cycle = 2.375 µs (board, 8 MHz)
.bss 4096 byte: 3095 cycle = 386.875 µs (board, 8 MHz)
.bss 8192 byte: 6167 cycle = 770.875 µs (board, 8 MHz)
প্রতি word শূন্য করতে 3 cycle
Cortex-M3 @ 8 MHz: 12 cycle = 1.500 µs
Cortex-M3 @ 72 MHz: 12 cycle = 0.167 µs
UART byte 115200 D= 86.8 µs, দেরি 10 µs = D-এর 11.5200%
UART byte 115200 D= 86.8 µs, দেরি 99 µs = D-এর 114.0480%
cold room alarm D=2000000.0 µs, দেরি 10 µs = D-এর 0.0005%
cold room alarm D=2000000.0 µs, দেরি 99 µs = D-এর 0.0049%
1 kHz loop D= 1000.0 µs, দেরি 10 µs = D-এর 1.0000%
1 kHz loop D= 1000.0 µs, দেরি 99 µs = D-এর 9.9000%
প্রথম তিন লাইন board-এর তিনটি সত্যিকারের run (exit পর্যন্ত, তাই খালি firmware-এ 13-এর বদলে 19). প্রতি 4 KiB .bss যোগ করলে ঠিক 3072 cycle বাড়ে: word প্রতি তিনটি নির্দেশ। শেষ ছয় লাইন একটি অনুপাত মাত্র, মাপ নয়: “কয়েক দশ µs”-কে দুই প্রান্ত 10 আর 99 µs ধরে দেখা হয়েছে প্রতিটি deadline-এর কতটা খেয়ে ফেলে। Alarm-এর পাশে নগণ্য, UART byte-এর পাশে সম্পূর্ণ, মাঝের 1 kHz loop-এ সর্বোচ্চ প্রায় ১০%. এই অনুপাতই সিদ্ধান্তের ভাষা।
PREEMPT_RT থাকলেও program-কে নিজের দিকটা ঠিক রাখতে হয়: real-time thread-কে SCHED_FIFO-এর মতো policy আর priority দেওয়া, mlockall() দিয়ে মেমরি আগেই আটকে রাখা যাতে চলার সময় page fault না হয়, আর সময়-নির্ভর loop-এ heap থেকে মেমরি না চাওয়া (উদাহরণ, চালানো হয়নি). এগুলো RTOS-এর নিয়মের মতোই শোনায়, কারণ সমস্যাটি একই।
৭ · বাজারঘরের জন্য বাছাই — scale, cold room আর গুদামের gateway
এখন কোর্সের দুটি যন্ত্র, আর একটি নতুন: বাজারঘরের গুদামে একটি gateway, যা দোকানের সব scale আর cold room-এর বার্তা জড়ো করে, ইন্টারনেট না থাকলে জমিয়ে রাখে, আর মালিকের ফোনে একটি dashboard দেখায়। প্রতিটির প্রয়োজন তিনটি প্রশ্নে যাচাই করা যায়: (১) বড় software stack লাগে কি? (২) কতগুলো স্বাধীন সময়ের কাজ? (৩) RAM আর hardware কি সেই বাছাই বহন করবে?
| যন্ত্র | |
| প্রশ্ন | |
| উত্তর | |
| সিদ্ধান্ত |
- Scale, প্রশ্ন ১। ওজন মাপা, দাম হিসাব, display: সবই ছোট আর নির্দিষ্ট। File system বা বহু protocol লাগে না।
- Scale, প্রশ্ন ২। দুটি কাজ: প্রতি 100 ms-এ ADC আর debounce করা tare বোতাম। পর্ব ৫৫-এ এই firmware super loop আর state machine-এ board-এ চলেছে; bare-metal যথেষ্ট।
- Cold room, প্রশ্ন ১। এখানেও বড় stack লাগে না; একটি MQTT client আর একটি ছোট TCP/IP stack MCU-তে চলে।
- Cold room, প্রশ্ন ২। চারটি কাজ আলাদা ছন্দে: 1 s-এর reading, alarm-এর সিদ্ধান্ত, 10 s-এর telemetry, আর network-এর অনিশ্চিত অপেক্ষা। Network-এর অপেক্ষা যেন alarm আটকাতে না পারে, সেজন্য task আর priority: RTOS (পর্ব ৫৬ থেকে ৫৮).
- Gateway, প্রশ্ন ১। MQTT broker, cloud-এ TLS, ইন্টারনেট না থাকলে local database, web dashboard, নিজের OTA update: প্রতিটি Linux-এ তৈরি পাওয়া যায়, MCU-তে নিজে লিখতে বছর লাগবে। উত্তর হ্যাঁ।
- Gateway, প্রশ্ন ৩। এই কাল্পনিক নকশায় 512 MiB RAM-এর একটি Cortex-A-ধাঁচের SoC ধরা হলো: Linux-এর জন্য যথেষ্ট জায়গা। 20 KiB SRAM-এর MCU-তে এই উত্তর অসম্ভব, প্রশ্ন ১-এর “হ্যাঁ” তখন hardware বদলাতে বলে।
- নির্ভরতার দিক। Gateway বন্ধ বা boot হলেও scale দাম দেখায় আর cold room-এর PA6 alarm বাজে। Gateway শুধু ইতিহাস আর দূরের দেখা। এই ভাগই নিরাপদ নকশা: hard কাজ ছোট, সরল যন্ত্রে।
একই যুক্তি একটি ছোট Python ফাংশনে; নিয়মগুলো শিক্ষার জন্য সরল করা, কোনো সর্বজনীন সূত্র নয়:
# তিনটি পণ্য, তিনটি প্রশ্ন: bare-metal, RTOS না embedded Linux?
products = { # rich: বড় software stack লাগে? jobs: স্বাধীন কাজ; ram: KiB
"scale": dict(rich=False, jobs=["ADC 100 ms", "tare বোতাম"], ram=20),
"coldroom": dict(rich=False, jobs=["reading 1 s", "alarm", "telemetry 10 s",
"network stack"], ram=20),
"gateway": dict(rich=True, jobs=["MQTT broker", "TLS-এ cloud", "local database",
"web dashboard", "OTA"], ram=512 * 1024),
}
def choose(p):
why = []
if p["rich"]: # প্রশ্ন ১
why.append("বহু protocol, file system, নানা program -> MMU আর Linux")
if p["ram"] < 32 * 1024:
why.append("সতর্কতা: RAM কম, hardware বদলান")
return "embedded Linux", why
n = len(p["jobs"])
if n >= 3: # প্রশ্ন ২
why.append(f"{n}টি স্বাধীন কাজ, আলাদা ছন্দ -> task আর priority")
return "RTOS", why
why.append(f"{n}টি সরল কাজ -> super loop + interrupt যথেষ্ট")
return "bare-metal", why
for name, p in products.items():
pick, why = choose(p)
print(f"{name:9}: {', '.join(p['jobs'])}")
print(f"{'':9} => {pick}; " + "; ".join(why))আসল আউটপুট (ব্রাউজারের Python):
scale : ADC 100 ms, tare বোতাম
=> bare-metal; 2টি সরল কাজ -> super loop + interrupt যথেষ্ট
coldroom : reading 1 s, alarm, telemetry 10 s, network stack
=> RTOS; 4টি স্বাধীন কাজ, আলাদা ছন্দ -> task আর priority
gateway : MQTT broker, TLS-এ cloud, local database, web dashboard, OTA
=> embedded Linux; বহু protocol, file system, নানা program -> MMU আর Linux
তিনটি যন্ত্র, তিনটি ভিন্ন উত্তর, আর প্রতিটির কারণ লেখা। “৩টি কাজ হলেই RTOS” সীমাটি একটি শিক্ষণীয় সরলীকরণ: অনেক ভালো firmware পাঁচ-ছয়টি কাজ super loop-এ চালায়, যদি প্রতিটি ছোট আর অ-blocking হয় (পর্ব ৫৫). আসল প্রশ্ন হলো কোনো ধীর কাজ, যেমন network-এর অপেক্ষা, কি জরুরি কাজকে আটকাতে পারে? পারলে task আর priority-র কারণ তৈরি হলো। Gateway কীভাবে device আর cloud-এর মাঝে বসে, সেই architecture মডিউল ১২-এর পর্ব ৭০ (IoT architecture)-এ।
শিল্পে প্রায়ই তিনটি এক বাক্সে থাকে। কিছু SoC-তে Cortex-A core-এর পাশে একটি Cortex-M core বসানো থাকে: Linux UI, network আর database সামলায়, পাশের MCU-core RTOS বা bare-metal-এ সময়-নির্ভর কাজ। Linux kernel-এর remoteproc আর RPMsg নামের কাঠামো এমন দ্বিতীয় core চালু করা আর তার সঙ্গে বার্তা বিনিময়ের জন্য। বাজারঘরের নকশাও এই দর্শনের: আলাদা বাক্স, একই ভাগ।
আরও গভীরে: Device tree-র শিকড় Open Firmware (IEEE 1275) নামের মানদণ্ডে, যা PowerPC-র Linux অনেক আগে থেকে ব্যবহার করত। ২০১১ সালের দিকে ARM Linux-এ প্রতিটি board-এর জন্য আলাদা C ফাইলের ভিড় নিয়ে Linus Torvalds-এর প্রকাশ্য সমালোচনার পরে ARM জগৎ দ্রুত device tree-তে সরে আসে বলে সাধারণত বর্ণনা করা হয়। মজার বিষয়, MCU-র জগতেও ধারণাটি পৌঁছেছে: Zephyr RTOS build-এর সময় devicetree থেকে C header বানায়, তাই একই firmware নানা board-এ যায়।
পরীক্ষা ও ইন্টারভিউতে: “Cortex-M-এ সাধারণ Linux চলে না কেন?” → MMU নেই, আর on-chip RAM KiB-এর ঘরে; Linux-এর process সুরক্ষা আর virtual memory MMU-নির্ভর। “Device tree কী কাজ করে?” → hardware-এর বর্ণনা kernel-এর কোড থেকে আলাদা রাখে; compatible দিয়ে driver মেলে। “sysfs GPIO না character device?” → kernel-এর নথিতে sysfs GPIO obsolete; নতুন কাজে /dev/gpiochipN আর libgpiod. “PREEMPT_RT কি Linux-কে hard real-time বানায়?” → latency অনেক কমায় আর সীমিত করে, কিন্তু প্রমাণিত WCET দেয় না; মেপে যাচাই লাগে। “কখন bare-metal যথেষ্ট?” → কাজ কম, ছোট আর অ-blocking হলে, আর কোনো ধীর কাজ জরুরি কাজকে আটকাতে না পারলে।
৮ · AI-এর যুগে OS বাছাই যাচাই
“আমার IoT যন্ত্রে কোন OS?” প্রশ্নে AI assistant প্রায়ই একটি জনপ্রিয় উত্তর দেয়, প্রয়োজনের তালিকা না চেয়েই। সাধারণ ভুল আর ধরার উপায়:
| AI প্রায়ই যা করে | কীভাবে ধরবেন |
|---|---|
| ছোট sensor যন্ত্রেও Linux সুপারিশ, বা Cortex-M-এ Linux চালানোর কথা বলে | Chip-এর datasheet: MMU আছে কি, RAM কত; ARM-এর নথি অনুযায়ী Cortex-M-এ MMU নেই |
পুরোনো /sys/class/gpio/export পথ শেখায় | Kernel-এর GPIO নথি: sysfs GPIO obsolete; libgpiod v2-এর man page মিলিয়ে কমান্ড |
Device tree-তে property বা compatible বানিয়ে দেয় | Kernel-এর Documentation/devicetree/bindings-এ binding খুঁজে মেলানো; dtc দিয়ে compile করে দেখা |
| “PREEMPT_RT মানে hard real-time” বা উৎস ছাড়া latency সংখ্যা | নিজের board-এ load-সহ মাপা; সংখ্যার উৎস চাওয়া; deadline-এর পাশে অনুপাত |
| Linux gateway-তে alarm-এর মতো জরুরি কাজ রাখে | Boot আর crash-এর সময় কে পাহারা দেয়, লিখে দেখা; জরুরি কাজ MCU-তে |
| Default password, খোলা SSH আর unsigned update রেখে দেয় | প্রতিটি যন্ত্রের আলাদা credential, TLS, signed update (পর্ব ৭৬, ৭৭) |
প্রয়োজন আর যাচাইয়ের শর্ত প্রথমেই দিন:
AI-এর উত্তর হাতে পেলে — যাচাইয়ের চেকলিস্ট
ভাবনার প্রশ্ন
প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন, তারপর “→ উত্তর” চাপুন।
প্র ০১MMU ছাড়া Linux (একসময়ের uClinux) তো আছে। তাহলে একটি Cortex-M-এ Linux চালিয়ে MCU-র কম দাম আর কম বিদ্যুৎ, আর Linux-এর সুবিধা, দুটিই কেন নেওয়া হয় না?
MMU-হীন Linux-এর ইতিহাস লম্বা। ১৯৯০-এর দশকের শেষ দিকে uClinux প্রকল্প MMU ছাড়া processor-এ Linux চালানোর কাজ শুরু করে, আর পরে সেই সমর্থন মূল kernel-এ ঢোকে; এখন কয়েকটি architecture-এ CONFIG_MMU=n কনফিগারেশন হিসেবে আছে। কিছু Cortex-M chip-এও এভাবে Linux চালানোর উদাহরণ আছে, সাধারণত বাইরের SDRAM জুড়ে। তাহলে সমস্যা কোথায়?
প্রথম সমস্যা মেমরি। Linux kernel আর একটি ন্যূনতম user space-এর জন্য MB মাপের RAM লাগে, যেখানে সাধারণ MCU-র on-chip SRAM KiB-এর ঘরে; বাজারঘর board-এ 20 KiB. তাই MCU-তে Linux মানে বাইরে একটি RAM chip, যা MCU-র মূল সুবিধা, “এক chip-এ সব”, নষ্ট করে। দ্বিতীয় সমস্যা সুরক্ষা। MMU না থাকলে সব process একই ঠিকানা-জগতে; একটি program-এর ভুল pointer kernel বা অন্য program-এর মেমরি নষ্ট করতে পারে। Linux-এর যে সুবিধার জন্য তাকে বেছে নেওয়া, “একটি program মরলে বাকিরা বাঁচে”, সেটিই চলে যায়। তৃতীয়, fork() কাজ করে না, কারণ একই virtual ঠিকানায় দুটি কপি রাখা যায় না; vfork() আর সাবধানে লেখা program লাগে, অনেক সাধারণ Linux software বদলাতে হয়। চতুর্থ, মেমরির খণ্ডিত হওয়া: MMU থাকলে ছড়ানো physical page জুড়ে একটি টানা virtual এলাকা বানানো যায়, না থাকলে বড় টানা জায়গা খুঁজতে হয়, আর দীর্ঘ সময় চললে তা পাওয়া কঠিন হয়।
সব মিলিয়ে MMU-হীন Linux একটি বিশেষ সমাধান, যেখানে Linux-এর কিছু driver বা tool খুব দরকার কিন্তু MMU-সহ chip ব্যবহার করা যায় না। সাধারণ পণ্যে দুটি পথ বেশি যুক্তিসংগত: MCU-তে RTOS, যা কম মেমরিতে নিশ্চিত সময় দেয়, বা ছোট একটি MMU-সহ application processor, যেখানে পূর্ণ Linux চলে। মাঝের পথে প্রায়ই দুই দিকের অসুবিধাই এসে জোটে।
বাজারঘরের দৃষ্টিতে প্রশ্নটি আরও সরল: cold room-এর MCU-কে Linux-এর কোন সুবিধা দরকার? কোনোটিই নয়, যা দরকার তা gateway-তে আছে। তাই সমাধান chip-এর ভেতরে মেশানো নয়, কাজ ভাগ করা।
মূল উপলব্ধি: Linux-এর মূল্য তার সুরক্ষা আর বিশাল software-এ, যার অনেকটাই MMU আর MB মাপের RAM-নির্ভর। MCU-তে Linux চালানো সম্ভব হলেও সাধারণত দুই জগতের খারাপ দিকগুলো একসাথে আনে।
প্র ০২PREEMPT_RT প্রায় দুই দশক আলাদা patch হয়ে থেকে ২০২৪ সালে মূল Linux-এ ঢুকল। এত সময় লাগল কেন, আর এখন কি একটি সাধারণ RTOS-এর জায়গা Linux নিতে পারে?
PREEMPT_RT-এর কাজ ২০০০-এর দশকের মাঝামাঝি শুরু হয়, Ingo Molnar আর Thomas Gleixner-এর নেতৃত্বে বলে সাধারণত বলা হয়। লক্ষ্য ছিল কঠিন: Linux kernel-এর প্রায় প্রতিটি কোণে, যেখানে preemption বা interrupt বন্ধ থাকে, সেই সময় ছোট আর সীমিত করা। এর জন্য spinlock-এর বেশিরভাগকে ঘুমাতে-পারা lock-এ বদলানো, interrupt handler-কে kernel thread বানানো, আর lock-এ priority inheritance দরকার হয়। প্রতিটি পরিবর্তন kernel-এর বহু subsystem ছুঁয়ে যায়, আর মূল kernel-এর রক্ষণাবেক্ষণকারীরা স্বাভাবিকভাবেই সাবধান, কারণ সাধারণ ব্যবহারকারীর throughput কমলে বা নতুন bug এলে ক্ষতি সবার।
তাই কাজটি টুকরো টুকরো করে মূল kernel-এ গেছে: উচ্চ-রেজোলিউশন timer, threaded interrupt, lock-এর নতুন অবকাঠামো, বছরের পর বছর ধরে। শেষ বড় বাধা ছিল console-এর printk-এর মতো অংশ। ২০২৪ সালের সেপ্টেম্বরে Linux 6.12-এর merge window-এ শেষ ধাপ যুক্ত হয়: x86, arm64 আর RISC-V-তে CONFIG_PREEMPT_RT বেছে নেওয়া যায়। দীর্ঘ সময়ের আরেক কারণ অর্থায়ন: এমন অবকাঠামোর কাজ কয়েকটি কোম্পানি আর Linux Foundation-এর একটি প্রকল্পের সহায়তায় চলেছে বলে জানা যায়।
তাহলে কি RTOS-এর দিন শেষ? না, কারণ দুটি ভিন্ন প্রশ্নের উত্তর দেয়। PREEMPT_RT একটি বড় application processor-এ Linux-এর সব সুবিধা রেখে latency-কে কয়েক দশ µs-এর ঘরে সীমিত করার পথ, প্রকাশিত মাপ অনুযায়ী। কিন্তু (১) এর জন্য MMU-সহ chip, MB মাপের RAM আর সেকেন্ডের boot লাগে, যা battery-চালিত sensor-এ চলে না; (২) সীমাটি মাপা, প্রমাণিত নয়: লক্ষ লক্ষ লাইনের kernel-এর WCET static-ভাবে প্রমাণ করা বাস্তবে প্রায় অসম্ভব, তাই কঠোর safety মানদণ্ডের যন্ত্রে প্রমাণের বোঝা ভারী; (৩) একটি ছোট RTOS-এর পুরো কোড একজন পড়ে বুঝতে পারেন, Linux-এর নয়।
যেখানে PREEMPT_RT সত্যিই জায়গা নিয়েছে: শিল্পের controller, অডিও আর রোবটিক্সের মতো ক্ষেত্র, যেখানে আগেই Linux লাগছিল (network, UI, file) আর সঙ্গে ms-এর নিচে নিয়মিত loop. সেখানে আগে প্রায়ই দুটি chip লাগত, এখন একটিতে চলতে পারে।
মূল উপলব্ধি: PREEMPT_RT Linux-কে “যথেষ্ট নির্ভরযোগ্য সময়” দেয়, প্রমাণিত সময় নয়, আর তা দেয় বড় hardware-এর দামে। ছোট, battery-চালিত বা প্রমাণ-নির্ভর কাজে RTOS আর bare-metal তাদের জায়গায় থাকে।
প্র ০৩MCU-র firmware-এ register-এর ঠিকানা সরাসরি header-এ লেখা থাকে, অথচ Linux একটি আলাদা device tree রাখে। এই আলাদা বর্ণনার সুবিধা কী, আর ARM Linux-এ এটি কীভাবে এল?
পর্ব ৩৬-এ আপনি দেখেছেন MCU-র firmware register-এর ঠিকানা struct আর macro-তে লিখে নেয়: বাজারঘর board-এর bazarghar.h-এ GPIOA 0x40010800. এটি সরল আর দ্রুত, কারণ firmware আর hardware এক জোড়া: একটি firmware একটি board-এর জন্য। Linux-এর অবস্থা উল্টো: একটি kernel-এর binary শত শত ভিন্ন board-এ চলতে চায়, যাদের CPU এক পরিবারের, কিন্তু কোন ঠিকানায় কোন controller, কোন pin-এ কী জোড়া, সব আলাদা।
PC-তে এই সমস্যা BIOS/UEFI-র ACPI টেবিল আর PCI-এর মতো নিজে-পরিচয় দেওয়া bus মেটায়: hardware নিজেই বলে “আমি আছি”। কিন্তু SoC-এর ভেতরের বেশিরভাগ peripheral নিজের পরিচয় দিতে পারে না: একটি I2C sensor থাকা মানে শুধু একটি ঠিকানায় একটি chip; কেউ না বললে kernel জানে না। ARM Linux প্রথমে এর সমাধান করত প্রতিটি board-এর জন্য আলাদা C ফাইলে (board file), যেখানে এই সব তথ্য কোডে লেখা। Board-এর সংখ্যা বাড়তে বাড়তে kernel-এর ARM অংশে বিপুল পরিবর্তন জমতে থাকে; ২০১১ সালের দিকে Linus Torvalds এই ভিড়ের প্রকাশ্য সমালোচনা করেন বলে সাধারণত উল্লেখ করা হয়, আর এরপর ARM জগৎ দ্রুত device tree-তে সরে আসে। ধারণাটি নতুন ছিল না: Open Firmware (IEEE 1275) থেকে আসা, PowerPC-র Linux আগে থেকেই ব্যবহার করত।
সুবিধা তিনটি। এক, kernel-এর কোড আর board-এর তথ্য আলাদা: নতুন board মানে প্রায়ই শুধু একটি নতুন .dts, kernel-এর কোড নয়। দুই, একটি kernel binary বহু board-এ চলে, শুধু DTB বদলায়। তিন, driver পুনর্ব্যবহারযোগ্য: TMP102-এর driver জানে না সে কোন board-এ, শুধু জানে কোন bus আর কোন address, যা device tree বলে।
দামও আছে: আরেকটি ভাষা আর tool (dtc), ভুল property দিলে driver চুপচাপ যুক্ত হয় না, আর ভুলের খোঁজ boot log পড়ে করতে হয়। মজার বিষয়, MCU-র জগৎও এই পথে আসছে: Zephyr RTOS devicetree ব্যবহার করে, তবে build-এর সময় তা থেকে C header বানায়, যাতে চলার সময় কোনো খরচ না থাকে।
মূল উপলব্ধি: যেখানে এক firmware এক board, সেখানে header-এ লেখা ঠিকানাই সেরা। যেখানে এক kernel বহু board, সেখানে hardware-এর বর্ণনা কোড থেকে আলাদা রাখা রক্ষণাবেক্ষণকে সম্ভব করে।
প্র ০৪অনেক আধুনিক SoC-তে একটি Cortex-A core-এর পাশে একটি Cortex-M core থাকে। একই chip-এ Linux আর RTOS পাশাপাশি চালানোর যুক্তি কী, আর এতে নতুন কী ঝুঁকি আসে?
এই নকশাকে বলে heterogeneous multiprocessing: ভিন্ন জাতের core এক chip-এ। কয়েকটি পরিচিত SoC পরিবারে, যেমন STMicroelectronics-এর STM32MP1 বা NXP-এর i.MX 8M-এর কিছু সদস্যে, Cortex-A core-এর সঙ্গে একটি Cortex-M core (যেমন Cortex-M4) থাকে বলে নির্মাতাদের নথিতে উল্লেখ আছে; নির্দিষ্ট মডেলের তথ্য datasheet-এ মিলিয়ে নিতে হয়। যুক্তি সরল: Linux network, UI, file system আর update সামলায়, যা সে ভালো পারে; Cortex-M-এ RTOS বা bare-metal সেই কাজ করে যার deadline µs-এর বা যা Linux boot হওয়ার আগেই চালু থাকা দরকার, যেমন motor-এর নিয়ন্ত্রণ বা একটি নিরাপত্তা-সংকেত।
Linux kernel-এ এর জন্য তৈরি কাঠামো আছে: remoteproc দিয়ে Linux পাশের core-এ firmware বসিয়ে চালু বা বন্ধ করতে পারে, আর RPMsg দিয়ে দুই দিকে বার্তা পাঠায়, ভাগ করা মেমরি আর একটি mailbox-ধাঁচের interrupt ব্যবহার করে। ফলে বাজারঘরের মতো নকশা, যেখানে MCU আর gateway আলাদা বাক্স আর MQTT দিয়ে কথা বলে, এক বোর্ডে নামিয়ে আনা যায়: কম তার, কম যন্ত্র।
কিন্তু নতুন ঝুঁকি তিনটি। এক, নির্ভরতা: Linux যদি Cortex-M-এর firmware চালু করে, তাহলে Linux boot না হওয়া পর্যন্ত MCU-core চলে না; জরুরি কাজের জন্য chip-এর boot-এর নকশা এমন হতে হয় যাতে MCU-core আগে বা স্বাধীনভাবে চালু হয়। দুই, ভাগ করা সম্পদ: একই clock, power, DRAM আর bus. Linux-এর একটি driver ভুল করে একটি clock বন্ধ করলে বা DRAM-এর bus ভিড় করলে MCU-core-এর সময়ের হিসাব ভেঙে যেতে পারে; তাই resource-এর মালিকানা device tree আর firmware-এ স্পষ্ট ভাগ করতে হয়। তিন, নিরাপত্তা: যে core-এর memory যে core ছুঁতে পারে, তার সীমা না দিলে Linux-এ একটি আক্রমণ MCU-core-এর firmware-ও বদলে দিতে পারে।
আলাদা বাক্সে এই ঝুঁকিগুলো কম, কারণ ভাগ করার কিছু নেই: gateway পুরো পুড়ে গেলেও cold room-এর alarm বাজে। একই chip-এ আনলে দাম আর আকার কমে, কিন্তু স্বাধীনতা প্রমাণ করার দায় বাড়ে।
মূল উপলব্ধি: Linux আর RTOS পাশাপাশি রাখা প্রতিটির শক্তি কাজে লাগায়, কিন্তু একই chip-এ ভাগ করা clock, power আর মেমরি নতুন নির্ভরতা আনে। জরুরি কাজের স্বাধীনতা নকশায় লিখে প্রমাণ করতে হয়।
প্র ০৫বাংলাদেশে load-shedding-এ যেকোনো মুহূর্তে বিদ্যুৎ চলে যায়। একটি MCU যন্ত্রের তুলনায় একটি Linux gateway-এর জন্য এটি কেন বড় সমস্যা, আর নকশায় কী কী রক্ষা রাখা উচিত?
MCU-র firmware থাকে flash-এ, আর সাধারণ কাজে সে flash-এ লেখে না; RAM-এর সব হারালেও পরের boot-এ একই firmware একই অবস্থা থেকে শুরু করে, আর এই পর্বের board-এ 13টি নির্দেশে main(). বিদ্যুৎ চলে যাওয়া তার কাছে একটি reset মাত্র। কিছু অবস্থা টিকিয়ে রাখতে হলে (যেমন scale-এর tare) নকশাকার সচেতনভাবে ছোট একটি এলাকায় লেখেন, প্রায়ই দুই কপিতে আর checksum-সহ।
Linux gateway-এর অবস্থা আলাদা। এর root file system একটি storage-এ (eMMC, SD card), আর সারাক্ষণ সেখানে লেখা চলে: log, database, update-এর ফাইল। Linux লেখাকে কিছুক্ষণ RAM-এ জমিয়ে রাখে (page cache), পরে একসাথে storage-এ পাঠায়। লেখার মাঝপথে বিদ্যুৎ গেলে একটি ফাইল অর্ধেক লেখা থাকতে পারে, আর খারাপ ক্ষেত্রে file system-এর নিজের হিসাব নষ্ট হয়ে পরের boot আটকে যায়। Journaling file system এই ঝুঁকি অনেক কমায়, কারণ পরিবর্তন আগে একটি journal-এ লেখে, কিন্তু ফাইলের ভেতরের তথ্য ঠিক থাকবে, এমন নিশ্চয়তা সব mode-এ দেয় না। SD card-এর মতো সস্তা storage-এর নিজের controller-ও বিদ্যুৎ যাওয়ার মুহূর্তে ভুল করতে পারে বলে অভিজ্ঞদের সতর্কতা আছে।
তাই gateway-এর নকশায় সাধারণ রক্ষাগুলো: (১) root file system read-only রাখা, আর পরিবর্তনশীল তথ্য একটি আলাদা partition-এ; (২) database-এর মতো লেখায় transaction আর নিয়মিত fsync, যাতে “লেখা হয়েছে” মানে সত্যিই storage-এ; (৩) update-এর জন্য A/B দুই partition: নতুন image একটিতে লিখে যাচাই করে তবেই সেখান থেকে boot, ব্যর্থ হলে পুরোনোটিতে ফেরা (পর্ব ৭৫ আর ৭৭-এর বিষয়); (৪) একটি ছোট UPS বা supercapacitor, যাতে বিদ্যুৎ গেলে কয়েক সেকেন্ডে গুছিয়ে বন্ধ হওয়া যায়; (৫) watchdog, যাতে boot আটকে গেলেও যন্ত্র নিজে আবার চেষ্টা করে (পর্ব ৬১).
আর সবচেয়ে বড় রক্ষা নকশার ভাগে: cold room-এর alarm, যার সামনে মাছ-মাংসের দাম, gateway-এর ওপর নির্ভর করে না। বিদ্যুৎ ফিরলে MCU প্রায় সঙ্গে সঙ্গে পাহারায় ফেরে; gateway কয়েক সেকেন্ড পরে এসে জমে থাকা ইতিহাস তুলে নেয়।
মূল উপলব্ধি: যে যন্ত্র storage-এ সারাক্ষণ লেখে, তার কাছে হঠাৎ বিদ্যুৎ যাওয়া তথ্য নষ্টের ঝুঁকি। Read-only root, A/B update আর জরুরি কাজ MCU-তে রাখা, এই তিন অভ্যাস Linux gateway-কে load-shedding-এর দেশে নির্ভরযোগ্য করে।
অনুশীলন
প্রথমে নিজে লিখুন বা হিসাব করুন, তারপর উত্তর খুলুন। যেখানে সম্ভব, উত্তর board, Clang বা Python-এ চালিয়ে যাচাই করা।
-
নকশা ও বাস্তবায়ন — gateway-এ তাপমাত্রা পড়া: Gateway-এর Linux-এ গুদামের একটি TMP102-ধাঁচের sensor-এর driver চলছে, আর মান আসে hwmon-এর ফাইলে (যেমন
/sys/class/hwmon/hwmon0/temp1_input), millidegree Celsius-এ, যেমন8250. একটি C ফাংশন লিখুন যা ফাইলটি পড়ে মানকে 0.01 °C-এর integer-এ (cold room-এর মতো দুই দশমিক) কাছের মানে গোল করে ফেরত দেয়, ঋণাত্মক মানসহ, আর ফাইল না থাকা ও ভুল লেখা আলাদা error হিসেবে জানায়।/* hwmon: temp1_input = millidegree Celsius, e.g. "8250\n" */ static int read_temp_centi(const char *path, int *centi) { FILE *f = fopen(path, "r"); if (!f) return -1; /* sensor/driver missing */ long milli; int ok = fscanf(f, "%ld", &milli) == 1; fclose(f); if (!ok) return -2; /* bad text */ /* round to nearest 0.01 C, also for negatives */ *centi = (int)((milli >= 0 ? milli + 5 : milli - 5) / 10); return 0; }এটি user space-এর সাধারণ ফাইল পড়া: I2C, register বা 0.0625 °C-এর গুণ, সব driver করেছে। কোনো Linux board না থাকায় ফাংশনটি Windows host-এ (Clang 22.1.8,
-Wall -Wextra, কোনো warning নেই) একটি ছোটmain()-সহ নকল ফাইল দিয়ে চালানো হলো (সত্যিকারের run):8250→ 8.25 C,-500→ -0.50 C,7004→ 7.00 C,-25000→ -25.00 C,abc→ error -2, ফাইল নেই → error -1. গোল করা “শূন্য থেকে দূরে অর্ধেক” নিয়মে, C-র integer ভাগ শূন্যের দিকে কাটে বলে ঋণাত্মকে আলাদা শাখা। নকশার দিক থেকে: error -1 মানে driver যুক্ত হয়নি (device tree বা bus-এর সমস্যা), error -2 মানে অপ্রত্যাশিত লেখা; দুটিকে আলাদা রাখলে gateway-এর log থেকে কারণ বোঝা যায়। আর hwmon-এর নম্বর (hwmon0) boot-ভেদে বদলাতে পারে, তাই আসল program-এnameফাইল পড়ে সঠিক sensor খোঁজা ভালো। -
ভুল খুঁজুন — একটি নকশা-নোট: “Cold room-এর MCU (Cortex-M3, 20 KiB SRAM) বদলে সেখানেই Linux আর PREEMPT_RT চালাব। Device tree-তে
compatible = "gpio-led";দিয়ে alarm LED বর্ণনা করব, আর program-এecho 6 > /sys/class/gpio/exportদিয়ে PA6 চালু করব। PREEMPT_RT থাকায় alarm এখন hard real-time-এ প্রমাণিত।” অন্তত চারটি ভুল দেখান।১, hardware: Cortex-M3-এ MMU নেই আর 20 KiB SRAM; সাধারণ Linux চলবে না। MMU-হীন Linux-ও MB মাপের বাইরের RAM চায় (ভাবনার প্রশ্ন ১). ২, binding: kernel-এর binding-এ
compatible = "gpio-leds"(s সহ), আর তা parent node-এ; LED-এর child node-এgpios = <&gpio1 6 GPIO_ACTIVE_HIGH>-এর মতো property লাগে। ভুল নামে কোনো driver যুক্ত হবে না, আর কোনো error-ও চোখে পড়বে না। ৩, sysfs: kernel-এর নথিতে sysfs GPIO obsolete; নতুন কাজে GPIO character device আর libgpiod. তাছাড়া সেখানে লেখা সংখ্যা একটি global GPIO নম্বর, “PA6”-এর 6 নয়, আর export-এর পরেdirection-এoutলিখে তবেইvalue. আর LED যদিgpio-ledsdriver-এর হাতে থাকে, সেই line অন্য পথে নেওয়া যায় না; তখন LED-এর নিজের sysfs interface ব্যবহার হয়। ৪, দাবি: PREEMPT_RT latency কমায় আর মাপে সীমিত করে, প্রমাণিত WCET দেয় না। ৫, প্রয়োজন: alarm-এর বাজেট সেকেন্ডের (পর্ব ৫৪-এ 2 s থেকে 3 s); Linux-এর কোনো সুবিধা এখানে লাগে না, বরং boot-এর সময় আর storage-এর ঝুঁকি যোগ হয়। সঠিক নকশা: cold room MCU-তে থাকে, gateway Linux-এ। -
আগে বলুন — board-এ reset থেকে main: কোর্সের virtual board-এ (1 নির্দেশ = 1 cycle, 8 MHz) একই
tomainfirmware-এ .bss-এ 4096 byte থাকলে run শেষ হয় 3095 cycle-এ, 8192 byte-এ 6167 cycle-এ। .bss-এ 12288 byte (3072 word) থাকলে কত cycle-এ শেষ হবে, আরMARK 1লাইনটি প্রায় কত ms-এ? আসল Cortex-M3-এ কি একই সংখ্যা আসবে?দুই run-এর পার্থক্য 6167 − 3095 = 3072 cycle প্রতি 1024 word, অর্থাৎ word প্রতি 3 cycle. বাকি অংশ 3095 − 3 × 1024 = 23. তাই 12288 byte-এ 23 + 3 × 3072 = 9239 cycle. MARK তার চার cycle আগে লেখা হয় (আগের run-গুলোতেও exit-এর 0.0004 ms আগে), তাই প্রায় 9235 ÷ 8000 ≈ 1.154 ms. Board-এ চালিয়ে মেলানো হলো (সত্যিকারের run):
[1.1545 ms] MARK 1আরexit(0) after 9239 cycles. আসল Cortex-M3-এ না: সেখানে store আর branch-এর cycle সংখ্যা আলাদা, flash-এর wait state যোগ হয়, আর reset-এর আগে clock স্থির হওয়ার সময় থাকে (Spec decision 17). Board-এর সংখ্যা শেখায় অনুপাত: .bss যত বড়, শূন্য করার loop তত লম্বা, যা MCU-র boot-এর একমাত্র বড় অংশ। Linux-এর boot-এ এমন একটি loop নয়, পুরো কয়েকটি ধাপ। -
হিসাব — 2 kHz-এর একটি নিয়ন্ত্রণ loop: গুদামের একটি conveyor motor-এর নিয়ন্ত্রণ loop 2 kHz-এ চলে (D = 500 µs). (ক) Cortex-M3, 72 MHz: interrupt-এ ঢোকা 12 cycle আর handler-এর কাজ 300 cycle (zero wait state ধরে); মোট সময় আর D-এর কত শতাংশ? (খ) Linux + PREEMPT_RT-এ সবচেয়ে খারাপ latency “কয়েক দশ µs” ধরে, ওপরের প্রান্ত 99 µs হলে শুধু latency-ই D-এর কত শতাংশ? (গ) কোর্সের board-এ একই handler 8 MHz-এ কত সময় দেখাবে, আর সেটি কেন সিদ্ধান্তে ব্যবহার করা যাবে না?
(ক) (12 + 300) ÷ 72 MHz = 4.333 µs; 4.333 ÷ 500 = 0.87%. প্রচুর জায়গা বাকি, আর প্রতিটি সংখ্যা হিসাবযোগ্য। (খ) 99 ÷ 500 = 19.8% (10 µs ধরলে 2%). এটি শুধু জেগে ওঠার দেরি; তার পরে handler-এর নিজের কাজ। Loop-টি সম্ভব, কিন্তু 99 µs কোনো প্রতিশ্রুতি নয়, প্রকাশিত মাপের ঘর; নিজের board-এ load-সহ মেপে, আর একটি miss হলে কী হয় তা ঠিক করে, তবেই। (গ) Board-এ ঢোকা 0 cycle আর প্রতি নির্দেশ 1 cycle (Spec decision 17), তাই 300 ÷ 8 MHz = 37.5 µs, যদি handler-এর 300টি নির্দেশ হয়। এটি না আসল Cortex-M3-এর সময়, না 72 MHz-এর; board যুক্তি যাচাই করে, সময় নয়। সব হিসাব Python-এ মেলানো হয়েছে। সিদ্ধান্ত: এই loop-এর জন্য MCU সবচেয়ে সহজ প্রমাণ দেয়; gateway-এর Linux-এ নিলে PREEMPT_RT আর মাপ দুটিই বাধ্যতামূলক।
নিজেকে যাচাই করুন
ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।
ক্রমএকটি সাধারণ ARM-ভিত্তিক embedded Linux board-এর boot-এর ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)
- Chip-এর ভেতরের Boot ROM চলে আর boot-এর storage বাছে
- প্রথম ধাপের ছোট loader DRAM চালু করে
- Bootloader (যেমন U-Boot) kernel আর device tree-র binary আনে
- Kernel MMU চালু করে আর device tree দেখে driver যুক্ত করে
- Root file system mount হয় আর init (PID 1) চলে
- Init service আর gateway-এর program চালু করে
একটি Cortex-M3 microcontroller-এ সাধারণ (MMU-নির্ভর) Linux চালানো যায় না, মূল কারণ কী?
- Cortex-M3-এর clock খুব ধীর
- Cortex-M3-এ MMU নেই, আর on-chip RAM খুব কম
- Cortex-M3 Thumb instruction চালায়, Linux পারে না
- Cortex-M3-এ কোনো interrupt controller নেই
Linux kernel-এ device tree-র compatible property-র কাজ কী?
- Driver-এর C কোড ভেতরে রাখা
- কোন program GPIO ব্যবহার করতে পারবে তা ঠিক করা
- Bootloader কোথায় আছে তা বলা
- Node-টির সঙ্গে কোন driver যুক্ত হবে তা মেলানো
Linux-এ নতুন একটি program থেকে GPIO চালাতে kernel-এর নথি কোন পথের পরামর্শ দেয়?
- GPIO character device (
/dev/gpiochipN), যেমন libgpiod দিয়ে /sys/class/gpio/exportদিয়ে sysfs GPIO- Program থেকে register-এর physical ঠিকানায় সরাসরি লেখা
- প্রতিবার device tree বদলে নতুন করে boot করা
PREEMPT_RT সম্পর্কে কোন বাক্যটি ঠিক?
- এটি চালু করলে Linux-এ প্রমাণিত hard real-time নিশ্চিত হয়
- এটি দিয়ে Linux Cortex-M microcontroller-এ চলে
- এটি Linux 6.12 থেকে মূল kernel-এ একটি config অপশন, প্রথমে x86, arm64 আর RISC-V-তে
- এটি এখনো শুধু মূল kernel-এর বাইরের patch
একটি দোকানের তাপমাত্রা monitor প্রতি 1 s-এ পড়ে, পরপর তিনটি খারাপ reading-এ alarm দেয়, আর একটি Linux gateway সব যন্ত্রের ইতিহাস জমায়। Alarm-এর সিদ্ধান্ত কোথায় রাখা উচিত, আর কেন?
- Gateway-তে, কারণ সেখানে বেশি CPU আছে
- Monitor-এর MCU-তে, যাতে gateway বন্ধ থাকলেও alarm বাজে
- Cloud-এ, কারণ সেখানে সব তথ্য একসাথে
- Gateway আর MCU দুটিতেই সমানভাবে, যে আগে বলে
Clang দিয়ে একই C program aarch64-linux-gnu target-এ বানানো হলো। ফাইলের ELF-এ /lib/ld-linux-aarch64.so.1 নামের interpreter আর libc.so.6-এর প্রয়োজন লেখা, আর .text মাত্র 216 byte. এর মানে কী?
- Program-টি dynamic link করা; চালাতে যন্ত্রে dynamic linker আর libc.so.6 লাগবে
- Program-টি static, তাই যেকোনো Linux-এ চলবে
- এটি একটি bare-metal firmware, flash-এ বসবে
- printf-এর পুরো কোড 216 byte-এর ভেতরে আছে
শব্দকোষ
লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:
মনে রাখুন
- প্রয়োজন থেকে শুরু: সরল কাজে bare-metal, কয়েকটি স্বাধীন সময়ের কাজে RTOS, বড় software stack-এ embedded Linux; প্রতিটির দাম মেমরি, boot, বিদ্যুৎ আর সময়ের নিশ্চয়তায়।
- MMU: সাধারণ Linux process-এর virtual memory আর সুরক্ষার জন্য MMU চায়; Cortex-M-এ নেই, তাই Linux Cortex-A-ধাঁচের application processor-এ, বাইরের DRAM-সহ।
- Boot: board-এ reset থেকে
main()13টি নির্দেশ; Linux-এ Boot ROM → loader → U-Boot → kernel + DTB → root file system → init → program. - Linux-এ hardware: device tree বর্ণনা করে,
compatibleদিয়ে driver মেলে, user space interface দিয়ে চায়; GPIO-তে character device আর libgpiod, sysfs GPIO obsolete. - সময়: Cortex-M3-এ interrupt-এ ঢোকা 12 cycle; PREEMPT_RT (Linux 6.12 থেকে মূল kernel-এ) প্রকাশিত মাপে প্রায় কয়েক দশ µs, প্রমাণিত নয়। জরুরি কাজ MCU-তে, ইতিহাস আর dashboard gateway-এ।
আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ
- মাইক্রোপ্রসেসর, এমবেডেড সিস্টেম ও IoT · কোর্স হোম৮৫টি পর্বপুরো কোর্সের মানচিত্র আর বাজারঘরের দুটি device-এর পথ।
- পর্ব ০৩ · Microprocessor, microcontroller আর SoCআগের ভিত্তিMMU, DRAM আর application SoC-এর প্রথম পরিচয়।
- পর্ব ৩২ · Boot আর startup codeআগের ভিত্তিReset vector থেকে main পর্যন্ত, board-এ ধাপে ধাপে।
- Operating Systems পর্ব ০৭ · বুট প্রক্রিয়াপাশের ট্র্যাকBIOS/UEFI, bootloader, kernel আর init, OS-এর দিক থেকে।
- Operating Systems পর্ব ২০ · Multiprocessor আর real-time schedulingপাশের ট্র্যাকReal-time Linux, PREEMPT_RT আর RTOS-এর বাছাই, OS তত্ত্বে।