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

এমবেডেড সিস্টেমের বৈশিষ্ট্য — সীমিত সম্পদ, real-time আর নির্ভরযোগ্যতা

Characteristics of Embedded Systems — Constrained Resources, Real-Time & Reliability

Taught in Bangla, this lesson defines an embedded system and its constraints: memory, word size, energy, cost, size and environment. Real Clang builds of the course firmware report flash sizes (the cold-storage firmware takes 1848 bytes), and a 16-bit int overflow is shown in C. In-page Python works out a power budget, super loop worst-case response (15 ms rising to 415 ms with one blocking task) and sensor fault checks. It covers hard, firm and soft real-time, watchdogs, fail-safe design and the development cycle.

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

  • একটি সাধারণ কম্পিউটার আর একটি এমবেডেড সিস্টেমের মূল পার্থক্য, বাংলাদেশের চেনা যন্ত্রের উদাহরণে
  • Memory, word size, শক্তি, খরচ আর আকারের সীমা কীভাবে firmware-এর প্রতিটি লাইনকে প্রভাবিত করে
  • একটি প্রয়োজনের তালিকাকে মাপা যায় এমন constraint-এর টেবিলে বদলানো
  • Hard, firm আর soft real-time; latency, jitter আর super loop-এর worst-case সাড়া
  • Watchdog, sensor-ত্রুটি ধরা আর fail-safe নকশা; firmware বনাম software; এমবেডেড development cycle

১ · এমবেডেড সিস্টেম কী — একটি কাজের জন্য তৈরি কম্পিউটার

আপনার বাসায় কয়টি কম্পিউটার আছে? ল্যাপটপ আর ফোন তো আছেই, কিন্তু টিভির রিমোট, মাইক্রোওয়েভ, ওয়াশিং মেশিন, প্রিপেইড মিটার, IPS-এর ভেতরেও একটি ছোট কম্পিউটার কাজ করছে। এদের নাম এমবেডেড সিস্টেম: একটি বড় যন্ত্রের ভেতরে “গেঁথে দেওয়া” (embedded) কম্পিউটার, যার কাজ একটাই এবং নির্দিষ্ট।

ধরে নেওয়া হচ্ছে আপনি C-এর মৌলিক জিনিস আর binary-hex ও লজিক গেট মোটামুটি জানেন; না জানলে C প্রোগ্রামিং আর Computer Architecture কোর্সে এক ঝলক দেখে নিন। এই পর্বে নতুন syntax নেই; আছে একটি অভ্যাস: প্রতিটি নকশা-সিদ্ধান্তের পেছনের সীমাটি দেখা।

উপমা — বড় রেস্তোরাঁর রাঁধুনি বনাম চায়ের দোকানের কেটলি: রাঁধুনি বিরিয়ানি থেকে পায়েস, যা বলবেন তা-ই রাঁধেন; তাঁর রান্নাঘরে অনেক চুলা, অনেক বাসন। এটি আপনার ল্যাপটপ, একটি general-purpose কম্পিউটার. চায়ের দোকানের কেটলি একটি কাজই জানে: পানি গরম রাখা। কিন্তু সে কাজটি দিনে কয়েকশো বার করে, সামান্য জ্বালানিতে, আর কখনো “restart করতে হবে” বলে বসে থাকে না। এমবেডেড সিস্টেম সেই কেটলির মতো: কাজ ছোট, কিন্তু দায়িত্ব বড়।

চেনা তিনটি উদাহরণ

  • ব্যাটারি-রিকশা বা ইজিবাইকের চার্জার: ভেতরের ছোট নিয়ন্ত্রক ব্যাটারির voltage আর current মাপে, চার্জিং-এর ধাপ বদলায়, ব্যাটারি ভরে গেলে বা অতিরিক্ত গরম হলে charge বন্ধ করে। ভুল হলে ব্যাটারি নষ্ট হয়, এমনকি আগুনও লাগতে পারে। (সতর্কতা: চার্জার mains বিদ্যুতে চলে; এর ভেতরে হাত দেওয়া প্রশিক্ষিত টেকনিশিয়ানের কাজ।)
  • গার্মেন্টস কারখানার আধুনিক সেলাই মেশিন: ভেতরের microcontroller মোটরের গতি আর সুঁইয়ের অবস্থান নিয়ন্ত্রণ করে, পা সরালেই সুঁই ঠিক ওপরের অবস্থানে থামায়, সেলাইয়ের সংখ্যা গোনে। সময়ের হিসাবে সামান্য গোলমালেই কাপড় নষ্ট হয়।
  • প্রিপেইড স্মার্ট মিটার: সারাক্ষণ বিদ্যুতের ব্যবহার মাপে, ব্যালান্স থেকে টাকা কাটে, ব্যালান্স শেষ হলে relay দিয়ে সংযোগ কাটে, কখনো network-এ তথ্য পাঠায়। এটি বছরের পর বছর দেয়ালে ঝুলে থাকে; কেউ এটিকে নিয়মিত restart করবে না।

এই কোর্সের চলমান প্রজেক্টেও দুটি এমবেডেড যন্ত্র আছে, কাল্পনিক দোকান বাজারঘর-এর জন্য (পরিচয় পর্ব ০১-এ)। Smart scale: load cell-এর সংকেত 12-bit ADC দিয়ে পড়ে, খালি অবস্থায় 400 count আর 2000 g ওজনে 1800 count ধরে calibration করে, তারপর ওজন × দর (আলু 65.50 টাকা/kg) দিয়ে দাম দেখায়; সর্বোচ্চ ওজন 5000 g. Cold-storage monitor: I2C sensor থেকে প্রতি 1 s-এ তাপমাত্রা পড়ে, 8.00 °C-এর ওপরে বা 0.00 °C-এর নিচে পরপর তিনটি পড়া এলে alarm বাজায়, আর প্রতি 10 s-এ MQTT-তে telemetry পাঠায়। এই সংখ্যাগুলো কোর্সের reference lab-এ স্থির করা; প্রতিটি পর্বে এগুলোই ব্যবহার হবে।

ছবি ৪.১ — বাজারঘরের cold-storage monitor-এর ভেতরের গঠন

Block diagram of a small embedded system

Cold-storage monitor: sensor, microcontroller, alarm আর telemetry Sensor I2C · 0x48 · 1 s বিদ্যুৎ adaptor, battery Microcontroller · BG-M3 Cortex-M38 MHz Flash128 KiB SRAM20 KiB SysTickপ্রতি 10 ms I2Csensor-এর bus Watchdogআটকালে reset GPIO · PA6alarm-এর pin UARTবাইরে বার্তা Alarm LED, buzzer Telemetry MQTT · প্রতি 10 s সীমা: memory · শক্তি সময় · নির্ভরযোগ্যতা
ছবি ৪.১ — Microcontroller-এর ভেতরের অংশগুলো কোর্সের virtual “বাজারঘর board” BG-M3-এর মাপে আঁকা। এটি কোনো আসল পণ্য নয়; আসল Cortex-M chip-এর আদলে তৈরি একটি শিক্ষার মডেল, যা পর্ব ০৬-এ বিস্তারিত দেখবেন। সবুজ বাক্স watchdog: অংশ ৬-এর মূল চরিত্র।

ছবিটি দেখলে সাধারণ কম্পিউটারের সঙ্গে পার্থক্যগুলো চোখে পড়ে। কোনো keyboard বা মনিটর নেই; ইনপুট আসে sensor থেকে, আউটপুট যায় একটি LED, একটি buzzer আর একটি network বার্তায়। সব অংশ একটি chip-এ (microprocessor, microcontroller আর SoC-এর পার্থক্য পর্ব ০৩-এ)। পার্থক্যগুলো এক জায়গায়:

দিকল্যাপটপ (general-purpose)Cold-storage monitor (embedded)
কাজব্যবহারকারী যা চান: লেখা, গান, গেম, কোডিংএকটিই: তাপমাত্রা পাহারা দেওয়া আর জানানো
Software বদলায় কেব্যবহারকারী নিজে app বসান, মোছেনশুধু নির্মাতা, firmware update দিয়ে
Memoryকয়েক GB RAM, শত শত GB storage20 KiB SRAM, 128 KiB flash
শক্তিদেয়ালের plug বা বড় battery, দিনে চার্জAdaptor, বিদ্যুৎ গেলে ছোট backup battery
সময়একটু ধীর হলে বিরক্তিAlarm দেরিতে বাজলে মাছ-সবজি নষ্ট
আয়ু আর পরিবেশকয়েক বছর, ঘরের ভেতরবহু বছর, ঠান্ডা আর আর্দ্র ঘরে, কেউ দেখে না
ব্যর্থ হলেRestart করে আবার কাজনিজে থেকেই ধরে ফেলে নিরাপদ অবস্থায় যেতে হয়

প্রথম microprocessor-এর জন্মই হয়েছিল একটি এমবেডেড পণ্যের জন্য। ১৯৭১ সালে Intel-এর 4004 তৈরি হয় একটি জাপানি নির্মাতার ক্যালকুলেটরের অনুরোধে: আলাদা আলাদা নির্দিষ্ট chip বানানোর বদলে একটি programmable chip আর তার ভেতরের program দিয়ে কাজটি করানো হয়। তারও আগে ১৯৬০-এর দশকে Apollo মহাকাশযানের guidance computer ছিল নির্দিষ্ট কাজের, কঠোর সীমার একটি কম্পিউটার, যাকে প্রায়ই প্রথম দিকের এমবেডেড কম্পিউটারগুলোর একটি বলা হয়। পুরো ইতিহাস পর্ব ০২-এ।

২ · সীমিত সম্পদ (১) — memory আর word size

এমবেডেড কাজের প্রথম ধাক্কা আসে memory-র মাপ দেখে। কোর্সের virtual board BG-M3-এ আছে 128 KiB flash (program থাকে, বিদ্যুৎ গেলেও মোছে না) আর 20 KiB SRAM (চলমান চলক আর stack). বাস্তবের একটি জনপ্রিয় 8-bit microcontroller ATmega328P-এর datasheet অনুযায়ী তাতে 32 KB flash আর মাত্র 2 KB SRAM. একটি সাধারণ ল্যাপটপের RAM এর লাখো গুণ বড়।

তাহলে বাজারঘরের firmware কতটুকু জায়গা নেয়? Reference lab-এর চারটি firmware আমার lab-এ Clang দিয়ে build করে ELF ফাইলের section-এর মাপ পড়া হলো (সত্যিকারের run; Clang 22.1.8, PyPI ziglang 0.17.1-এর সঙ্গে আসা; sizes.py একটি ছোট stdlib-Python script, যা ELF-এর section header পড়ে):

~/lab/_ref $ python -B board.py build firmware/coldroom.c -o ../charac/build/coldroom.elf
built ../charac/build/coldroom.elf
~/lab/charac $ python -B sizes.py build/blink.elf build/scale.elf build/coldroom.elf build/watchdog.elf
firmware    .text  .data   .bss .noinit    flash     SRAM
blink         508      0      4      0    0.39%    0.02%
scale        2188      0     12      0    1.67%    0.06%
coldroom     1848      0      4      0    1.41%    0.02%
watchdog     1252      0      4      8    0.96%    0.06%

পুরো cold-storage monitor, sensor পড়া, alarm-এর যুক্তি আর UART-এ লেখার কোডসহ, 1848 byte. Linker-এর নিজের map ফাইলও একই কথা বলে: .isr_vector 0x60 আর .text 0x6d8, যোগ করলে 0x738 = 1848 (এই পর্বে hex সংখ্যা C-এর রীতিতে 0x দিয়ে লেখা)। .data আর .bss হলো SRAM-এ রাখা global চলক; .noinit একটি বিশেষ অংশ, যা reset-এর পরেও মোছে না (অংশ ৬-এ কাজে লাগবে)। Stack এই হিসাবে নেই: board-এর linker script অন্তত 2 KiB stack-এর জায়গা ফাঁকা রাখতে বাধ্য করে (_min_stack = 2K), না থাকলে link-ই ব্যর্থ হয়। Memory map আর linker script-এর পুরো গল্প পর্ব ৩১-এ, stack-এর মাপ ঠিক করা পর্ব ৩৯-এ।

এত ছোট হওয়ার পেছনে কয়েকটি প্রচলিত রীতি:

  • Heap নেই, malloc নেই: সব buffer-এর মাপ compile-এর সময়েই ঠিক, তাই চলার মাঝে memory ফুরোয় না।
  • printf নেই: পুরো printf অনেক KiB নিতে পারে; বদলে board-এর ছোট uart_put_u32 আর uart_put_fixed2 ফাংশন।
  • Float নেই: Cortex-M3-এ hardware floating-point unit নেই, তাই দাম হিসাব হয় পয়সায়, পূর্ণসংখ্যায়: price_paisa = (net_g × 6550 + 500) / 1000. Fixed-point-এর পুরো কৌশল পর্ব ৪০-এ।

Word size — 16 bit-এর ঘরে বড় গুণফল

শুধু memory-র মোট মাপ নয়, প্রতিটি সংখ্যার “ঘরের” মাপও সীমা। 8-bit AVR-এর (যেমন ATmega328P) জনপ্রিয় compiler avr-gcc-তে int 16 bit. তাই সেখানে net_g * 6550u হিসাবটি হয় 16-bit unsigned গণিতে, আর 65535-এর বেশি হলেই ফল চুপচাপ ঘুরে যায় (integer overflow; unsigned-এ এটি নিয়মমাফিক wrap, কোনো error নেই)। নিচের C কোড ল্যাপটপে চলেও সেই 16-bit আচরণ হুবহু দেখায়, কারণ প্রতিটি মধ্যবর্তী মান জোর করে uint16_t-তে রাখা হয়েছে:

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

/* bazarghar smart scale: price_paisa = (net_g * 6550 + 500) / 1000 */
static uint32_t price32(uint32_t net_g)
{
    return (net_g * 6550u + 500u) / 1000u;
}

/* the same formula on a machine whose every value must fit in 16 bits */
static uint16_t price16(uint16_t net_g)
{
    uint16_t product = (uint16_t)(net_g * 6550u);   /* only the low 16 bits stay */
    uint16_t sum = (uint16_t)(product + 500u);
    return (uint16_t)(sum / 1000u);
}

int main(void)
{
    const uint16_t grams[] = {5, 9, 10, 150, 500, 1250};
    for (int i = 0; i < 6; i++) {
        uint16_t g = grams[i];
        printf("%5u g: 32-bit %5u paisa | 16-bit %5u paisa\n",
               (unsigned)g, (unsigned)price32(g), (unsigned)price16(g));
    }
    printf("16-bit is safe only up to %u g\n", (65535u - 500u) / 6550u);
    return 0;
}

আসল আউটপুট:

    5 g: 32-bit    33 paisa | 16-bit    33 paisa
    9 g: 32-bit    59 paisa | 16-bit    59 paisa
   10 g: 32-bit    66 paisa | 16-bit     0 paisa
  150 g: 32-bit   983 paisa | 16-bit    65 paisa
  500 g: 32-bit  3275 paisa | 16-bit    64 paisa
 1250 g: 32-bit  8188 paisa | 16-bit    61 paisa
16-bit is safe only up to 9 g

32-bit হিসাব README-র সংখ্যার সঙ্গে হুবহু মেলে: 150 g → 983 পয়সা = 9.83 টাকা, 500 g → 32.75 টাকা, 1250 g → 81.88 টাকা. 16-bit-এ মাত্র 9 g পর্যন্ত ঠিক থাকে। 10 g-এ গুণফল 65500, তাতে 500 যোগ করলে 66000, যা 65536 পেরিয়ে 464-এ ঘুরে যায়, তাই দাম 0. 1250 g আলুর দাম দেখাবে 61 পয়সা! সবচেয়ে বিপজ্জনক দিক: কোনো crash নেই, কোনো সতর্কবার্তা নেই, শুধু ভুল সংখ্যা। সমাধান একটি cast: (uint32_t)net_g * 6550u, যাতে গুণটি 32 bit-এ হয়। Two's complement আর overflow-এর তত্ত্ব Computer Architecture-এর পর্ব ০৫-এ, এই কোর্সের ব্যবহারিক দিক পর্ব ০৫-এ।

৩ · সীমিত সম্পদ (২) — শক্তি, খরচ, আকার আর পরিবেশ

বাংলাদেশে লোডশেডিং পরিচিত ঘটনা। Cold-storage monitor সাধারণত adaptor-এ চলে, কিন্তু বিদ্যুৎ গেলে ঠিক তখনই তার কাজ সবচেয়ে জরুরি: ঘর গরম হতে শুরু করে। তাই তার একটি backup battery আছে, আর প্রশ্ন দাঁড়ায়: এই battery কতক্ষণ চলবে? উত্তরের জন্য লাগে একটি power budget: যন্ত্রটি কোন অবস্থায় কতক্ষণ থাকে আর তখন কত current নেয়।

মূল সূত্র

গড় current = Σ (প্রতিটি অবস্থার current × সেই অবস্থার সময়ের ভগ্নাংশ); battery-র আয়ু (ঘণ্টা) ≈ ধারণক্ষমতা (mAh) ÷ গড় current (mA).

Microcontroller-এর বড় অস্ত্র sleep mode: কাজ না থাকলে CPU থামিয়ে প্রায় কিছুই খরচ না করা, আর timer বা interrupt এলে জেগে ওঠা। আমাদের board-এর firmware-এ __WFI() (“wait for interrupt”) নির্দেশ ঠিক এই কাজ করে। নিচের হিসাবটি চালিয়ে দেখুন। সব current উদাহরণের জন্য ধরা মান, কোনো নির্দিষ্ট chip-এর datasheet থেকে নয়; বাস্তব নকশায় datasheet আর মাপা মান লাগবে।

# cold-room monitor-এর backup battery: load-shedding-এর সময় কতক্ষণ চলবে?
# সব current উদাহরণের জন্য ধরা মান, কোনো নির্দিষ্ট chip-এর datasheet নয়।
BATTERY_mAh = 2000
ACTIVE_mA, SLEEP_mA = 8.0, 0.010      # MCU জেগে থাকলে / ঘুমালে
SAMPLE_ms = 2                          # প্রতি সেকেন্ডে একবার পড়া-হিসাব: 2 ms জাগা
RADIO_mA, RADIO_ms = 120.0, 300        # একবার Wi-Fi-তে telemetry পাঠানো

def average_mA(sleep, telemetry_every_s):
    if not sleep:                      # কখনো ঘুমায় না
        avg = ACTIVE_mA
    else:                              # 1 s-এর মধ্যে 2 ms জাগা, বাকিটা ঘুম
        avg = (ACTIVE_mA * SAMPLE_ms + SLEEP_mA * (1000 - SAMPLE_ms)) / 1000
    if telemetry_every_s:              # radio-র charge ভাগ করে প্রতি সেকেন্ডে
        avg += RADIO_mA * RADIO_ms / 1000 / telemetry_every_s
    return avg

plans = [("সবসময় জেগে, radio নেই", False, 0),
         ("ঘুম + জাগা, radio নেই", True, 0),
         ("ঘুম + প্রতি 10 s-এ Wi-Fi", True, 10),
         ("ঘুম + প্রতি 60 s-এ Wi-Fi", True, 60)]
for name, sleep, every in plans:
    avg = average_mA(sleep, every)
    hours = BATTERY_mAh / avg
    print(f"{name:26} গড় {avg:8.4f} mA -> {hours:8.1f} ঘণ্টা ({hours/24:6.1f} দিন)")

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

সবসময় জেগে, radio নেই     গড়   8.0000 mA ->    250.0 ঘণ্টা (  10.4 দিন)
ঘুম + জাগা, radio নেই      গড়   0.0260 mA ->  76982.3 ঘণ্টা (3207.6 দিন)
ঘুম + প্রতি 10 s-এ Wi-Fi   গড়   3.6260 mA ->    551.6 ঘণ্টা (  23.0 দিন)
ঘুম + প্রতি 60 s-এ Wi-Fi   গড়   0.6260 mA ->   3195.0 ঘণ্টা ( 133.1 দিন)

তিনটি শিক্ষা। এক: শুধু ঘুমাতে শিখলেই গড় current 8 mA থেকে প্রায় 0.026 mA, তিনশো গুণের বেশি কম। (৩২০০ দিনের সংখ্যাটি কাগুজে: battery নিজে নিজেও ধীরে খালি হয়, sensor-ও current নেয়; এগুলো পর্ব ৬২-এর হিসাবে আসবে।) দুই: radio যোগ হতেই ছবি বদলে যায়; প্রতি 10 s-এ একবার Wi-Fi-তে পাঠানোর খরচ (120 × 0.3 ÷ 10 = 3.6 mA গড়) বাকি সবকিছুর চেয়ে শতগুণ বড়। তিন: তাই নকশায় প্রশ্ন ওঠে, বিদ্যুৎ না থাকলে telemetry কি প্রতি 60 s-এ একসাথে পাঠানো যায়? এটি engineering-এর trade-off: তথ্যের সতেজতা বনাম battery-র আয়ু। Low-power নকশা পর্ব ৬০-এ, power budget পর্ব ৬২-এ, আর chip-স্তরের শক্তির তত্ত্ব Computer Architecture-এর পর্ব ৫৬-এ।

খরচ, আকার আর পরিবেশ

খরচ: একটি স্মার্ট মিটারের নকশা হয়তো লাখো ইউনিটে বানানো হবে; তখন প্রতিটি ইউনিটে একটু বড় chip বাদ দিলেই মোট সাশ্রয় বিশাল। এজন্যই এমবেডেড প্রকৌশলীরা প্রায়ই “যথেষ্ট” chip বাছেন, “সেরা” নয়, আর firmware-কে সেই ছোট chip-এ আঁটানোর চেষ্টা করেন। আকার: চার্জারের বাক্স, মিটারের খোল, সেলাই মেশিনের ভেতরের ফাঁকা জায়গা: board-কে সেখানেই আঁটতে হবে, পাখা ছাড়া, তাপ বের হওয়ার পথ ভেবে। পরিবেশ: cold-storage-এর ঠান্ডা আর আর্দ্রতা, কারখানার কম্পন আর তুলার ধুলা, গাড়ির ইঞ্জিনের তাপ। তাই এমবেডেড chip-এর datasheet-এ কাজের তাপমাত্রার পরিসর (operating temperature range) একটি গুরুত্বপূর্ণ সারি, আর একই chip প্রায়ই ভিন্ন ভিন্ন তাপমাত্রা-গ্রেডে পাওয়া যায়।

৪ · প্রয়োজন থেকে constraint — নকশার আগে সংখ্যায় লিখুন

বাজারঘরের মালিক একটি cold-storage monitor চান। তাঁর ভাষায় প্রয়োজনগুলো এমন: “ঘর বেশি গরম বা বেশি ঠান্ডা হলে জানাবে, বিদ্যুৎ গেলেও চলবে, দাম কম হবে, বছরের পর বছর চলবে।” এগুলো requirement, কিন্তু এখনো নকশার কাজে লাগার মতো নয়, কারণ “বেশি গরম” বা “দাম কম” মাপা যায় না। প্রকৌশলীর প্রথম কাজ প্রতিটি কথাকে একটি মাপা যায় এমন সীমা বা constraint-এ বদলানো। যন্ত্রটি কী করবে, তা functional requirement; কতটা ভালোভাবে, কত সময়ে, কত শক্তিতে করবে, তা non-functional requirement. এমবেডেড কাজে দ্বিতীয়টিই নকশাকে বেশি গড়ে দেয়।

মালিকের কথাসীমার ধরনমাপা যায় এমন constraint
“বেশি গরম বা ঠান্ডা হলে জানাবে”সময় (real-time)প্রতি 1 s-এ পড়া; 8.00 °C-এর ওপরে বা 0.00 °C-এর নিচে পরপর ৩টি পড়া এলে alarm, তাই প্রায় 3 s-এর মধ্যে
“ঘনঘন বাজবে না”আচরণের স্থিরতা0.50 °C hysteresis: alarm বন্ধ হবে 0.50…7.50 °C-এ পরপর ৩টি পড়ার পরে
“বিদ্যুৎ গেলেও চলবে”শক্তিপড়ার ফাঁকে sleep; battery-তে চললে telemetry-র হার কমানো যায়
“দাম কম হবে”খরচ আর memoryছোট MCU: 128 KiB flash, 20 KiB SRAM-এ আঁটবে; heap নেই, float নেই
“বছরের পর বছর চলবে”নির্ভরযোগ্যতাWatchdog চালু; sensor সাড়া না দিলে ধরা; reset-এর কারণ লিখে রাখা
“নষ্ট হলে যেন চুপ না থাকে”নিরাপত্তা (fail-safe)Sensor পরপর ৩ বার ব্যর্থ হলে alarm চালু: SENSOR FAULT
  1. সময়। “জানাবে” কথাটির সঙ্গে একটি সময় জুড়তেই এটি real-time constraint. বাজারঘরের নকশায় প্রতি 1 s-এ একটি পড়া আর পরপর ৩টি খারাপ পড়ার নিয়ম। তাই alarm ইচ্ছা করেই প্রায় 3 s দেরিতে আসে: একটি এলোমেলো পড়ায় যেন ভুল alarm না বাজে। এটি একটি সচেতন trade-off.
  2. স্থিরতা। তাপমাত্রা যদি 8.00 °C-এর আশপাশে দোল খায়, alarm বারবার চালু-বন্ধ হবে, আর মানুষ শেষে তা উপেক্ষা করতে শিখবে। সমাধান hysteresis: চালুর সীমা 8.00 °C, কিন্তু বন্ধের জন্য 7.50 °C-এ নামতে হবে। ঘরের এসির thermostat-ও একই কৌশলে চলে।
  3. শক্তি। “বিদ্যুৎ গেলেও” মানে battery, আর battery মানে প্রতিটি mA-এর হিসাব। উপরের হিসাব দেখিয়েছে, radio-ই সবচেয়ে বড় খরচ। তাই constraint-এ লেখা হলো: battery-তে চললে telemetry কম পাঠানো যাবে।
  4. খরচ আর memory. “দাম কম” মানে ছোট chip, আর ছোট chip মানে কম memory. এখানে সংখ্যা লিখে দেওয়া হলো: পুরো firmware 128 KiB flash আর 20 KiB SRAM-এ আঁটবে। Build-এর পরে map ফাইল দেখেই যাচাই হয় (আগের অংশে 1848 byte).
  5. নির্ভরযোগ্যতা। “বছরের পর বছর” মানে কোনো মানুষ reset বোতাম চাপবে না। Firmware আটকে গেলে watchdog reset করবে, আর পরের boot-এ কারণটি জানা যাবে। Sensor-এর তার ছিঁড়লেও তা ধরা পড়তে হবে।
  6. নিরাপত্তা। সবচেয়ে সূক্ষ্ম কথা: যন্ত্র নষ্ট হলে সে যেন চুপচাপ “সব ঠিক আছে” না দেখায়। Sensor ব্যর্থ হলে alarm বাজানোই নিরাপদ দিক। এটিই fail-safe চিন্তা, যা অংশ ৬-এ সত্যিকারের firmware run দিয়ে দেখবেন।

নিয়মটি মনে রাখুন: “দ্রুত”, “কম খরচে”, “নির্ভরযোগ্য” লেখা দেখলে প্রশ্ন করুন, “কত?” প্রতিটি constraint-এর পাশে একটি সংখ্যা আর যাচাইয়ের উপায় চাই: সময় simulator-এর লগে, memory map ফাইলে, শক্তি power budget-এ।

৫ · Real-time — সঠিক উত্তর, সঠিক সময়ে

একটি real-time system-এ উত্তরের সঠিকতা দুই অংশে: মান ঠিক হতে হবে, আর সময়মতো আসতে হবে। Cricket-এর DRS-এর সিদ্ধান্ত পরের ওভারে এলে তার কোনো দাম নেই। আর একটি ভুল ধারণা ভাঙা দরকার: real-time মানে “খুব দ্রুত” নয়, মানে “নিশ্চিতভাবে সময়ের মধ্যে”। প্রতি 1 s-এ তাপমাত্রা পড়া মোটেও দ্রুত নয়, কিন্তু প্রতিবার সময়মতো হলে এটি real-time.

ধরনDeadline পেরোলেউদাহরণ
Hard real-timeএকবার পেরোলেই ব্যর্থতা; প্রাণ বা বড় সম্পদের ঝুঁকিগাড়ির airbag, সেলাই মেশিনে হাত পড়লে মোটর থামানো
Firm real-timeদেরিতে আসা ফল মূল্যহীন, ফেলে দেওয়া হয়; মাঝেমধ্যে হলে সহ্য করা যায়কারখানার লাইনে চলমান পণ্যের ছবি পরীক্ষা
Soft real-timeদেরি হলে মান কমে, কিন্তু কাজ চলেভিডিও কল, cold-room-এর telemetry একটু দেরিতে পৌঁছানো

সময়ের তিনটি শব্দ এই কোর্স জুড়ে আসবে। Latency: কোনো ঘটনা ঘটা থেকে সাড়া পর্যন্ত সময়। Jitter: সেই সময় প্রতিবার কতটা ওঠানামা করে; প্রতি 1 s-এর পড়া কখনো 990 ms, কখনো 1010 ms পরে হলে তা jitter. WCET (worst-case execution time): একটি কাজ সবচেয়ে খারাপ অবস্থায় কতক্ষণ নেয়। Real-time নকশায় গড় নয়, সবচেয়ে খারাপ অবস্থাটাই প্রমাণ করতে হয়। এসবের পূর্ণ আলোচনা পর্ব ৫৪-এ; OS-এর দিক থেকে real-time scheduling Operating Systems কোর্সের পর্ব ২০-এ।

Super loop — সবচেয়ে সরল firmware কাঠামো

OS ছাড়া বেশিরভাগ ছোট firmware একটি super loop: main-এর ভেতরে একটি অসীম loop, যা কাজগুলো পালাক্রমে করে, যেমন স্কুলের দপ্তরি ঘড়ি দেখে দেখে ঘণ্টা বাজান। বাজারঘরের cold-storage firmware ঠিক এভাবে চলে: SysTick timer প্রতি 10 ms-এ একটি interrupt দিয়ে ticks বাড়ায়, আর loop প্রতি 100 tick (1 s) পরপর একবার কাজ করে, বাকি সময় __WFI()-তে ঘুমায়। নিচের stepper-এর মানগুলো reference firmware coldroom.c-এর সত্যিকারের run থেকে নেওয়া (README-র script: 4.5 s-এ 8.25 °C, 5.5 s-এ 9.00, 6.5 s-এ 9.50, 8.5 s-এ 7.75, 9.5 s-এ 7.00 °C); কোডটি সংক্ষিপ্ত রূপ, low_count বাদ দেওয়া।

1while (n < RUN_SAMPLES) {2  if (ticks < next) { __WFI(); continue; }3  next += 100; n++;4  tsens_read(&t16);5  high = (t16 > 8.00 C) ? high + 1 : 0;6  ok = (0.50 <= t16 <= 7.50) ? ok + 1 : 0;7  if (high >= 3) want = HIGH;8  else if (ok >= 3) want = OFF;9  if (want != state) { alarm(); }10  if (n % 10 == 0) telemetry();11}
চলকের মান
সময়
ticks · next
n · T
high · ok
state · PA6
  1. ঘুমিয়ে অপেক্ষা। সময় 4.5 s: ticks = 450, কিন্তু পরের কাজ 500-এ। তাই loop __WFI()-তে ঘুমায়; প্রতি 10 ms-এ SysTick জাগিয়ে ticks বাড়ায়, loop আবার দেখে, আবার ঘুমায়। আগের চারটি পড়া স্বাভাবিক ছিল, তাই ok = 4.
  2. 5 s: প্রথম গরম পড়া। ticks 500-এ পৌঁছাতেই কাজ: next হলো 600, n = 5. Sensor বলছে 8.25 °C, যা 8.00-এর বেশি, তাই high = 1; ভালো সীমার বাইরে, তাই ok শূন্যে ফিরল। একটি পড়ায় alarm নয়।
  3. 6 s: দ্বিতীয় গরম পড়া। 9.00 °C, high = 2. এখনো alarm নেই; নকশা অনুযায়ী তৃতীয় পড়ার অপেক্ষা।
  4. 7 s: alarm চালু। 9.50 °C, high = 3, তাই want = HIGH. state বদলাল, PA6 pin 1 হলো, UART-এ এলো ALARM ON: HIGH temperature. সত্যিকারের run-এ এটি 7000.0634 ms-এ; প্রথম 8.25 °C sensor-এ এসেছিল 4500 ms-এ। এই প্রায় 2.5 s দেরিটা ইচ্ছাকৃত।
  5. 8 s: চুপচাপ। 9.50 °C, high = 4. want আর state দুটোই HIGH, তাই নতুন কোনো বার্তা নেই। একই খবর বারবার না পাঠানো ভালো নকশা।
  6. 9 s: hysteresis-এর মাঝখানে। 7.75 °C: 8.00-এর বেশি নয়, তাই high = 0; কিন্তু 7.50-এর বেশি, তাই ভালোও নয়, ok = 0. Alarm চালুই থাকে। এই মাঝের ফালিটিই hysteresis-এর কাজ।
  7. 10 s: telemetry. 7.00 °C, ok = 1. n = 10, ১০ দিয়ে বিভাজ্য, তাই telemetry গেল: {"dev":"coldroom-1","seq":1,"temp_c":7.00,"alarm":"HIGH"}. Alarm এখনো HIGH, কারণ ৩টি ভালো পড়া হয়নি।
  8. 12 s: alarm বন্ধ। 11 s আর 12 s-এ আরও দুটি 7.00 °C, ok = 3, তাই want = OFF. PA6 নামল, UART-এ ALARM OFF (12000.0510 ms). পুরো চক্রে loop কখনো এক জায়গায় আটকে থাকেনি, সেটিই super loop-এর শর্ত।

Super loop সরল আর খুব প্রচলিত, কিন্তু কোনো একটি কাজ বেশিক্ষণ আটকে থাকলে বাকি সব কাজ অপেক্ষা করে। Smart scale-এর একটি কাল্পনিক super loop ধরুন: ওজন পড়া 3 ms, display হালনাগাদ 12 ms, button দেখা 0.1 ms. এর সঙ্গে প্রতি ৪০ বার loop ঘোরার পর একবার MQTT-তে পাঠানো, যা network-এর উত্তরের অপেক্ষায় 400 ms আটকে থাকে (blocking). Button চাপার পর সাড়া কত দেরিতে আসে? নিচের হিসাব প্রতিটি millisecond-এ একবার করে চাপ ধরে নিয়ে সবগুলোর অপেক্ষা গোনে (সব সময় ধরা মান):

# super loop-এ button চাপার পর কত দেরিতে সাড়া মেলে? (সময় ms-এ, ধরা মান)
from bisect import bisect_left
def loop_schedule(tasks, until_ms):
    """loop বারবার ঘোরে; ফেরত দেয় check_button যে যে মুহূর্তে চলে।"""
    t, loop_no, checks = 0, 0, []
    while t < until_ms:
        loop_no += 1
        for name, cost, every in tasks:        # every = কত নম্বর loop-এ একবার
            if loop_no % every == 0:
                if name == "check_button":
                    checks.append(t)
                t += cost
    return checks

def worst_response(tasks, deadline=50, until=10_000):
    checks = loop_schedule(tasks, until)
    waits = [checks[bisect_left(checks, press)] - press
             for press in range(0, until - 1000)]   # প্রতি ms-এ একবার চাপ
    late = sum(w > deadline for w in waits)
    return max(waits), sum(waits) / len(waits), late, len(waits)

base = [("read_scale", 3, 1), ("update_display", 12, 1), ("check_button", 0.1, 1)]
blocking = base + [("send_mqtt_blocking", 400, 40)]   # প্রতি 40 loop-এ একবার
for name, tasks in [("শুধু তিনটি কাজ", base), ("+ blocking MQTT send", blocking)]:
    worst, avg, late, total = worst_response(tasks)
    print(f"{name:22}: সবচেয়ে বেশি {worst:6.1f} ms, গড় {avg:5.1f} ms, "
          f"50 ms-এর বেশি দেরি {late}/{total} বার")

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

শুধু তিনটি কাজ        : সবচেয়ে বেশি   15.1 ms, গড়   7.5 ms, 50 ms-এর বেশি দেরি 0/9000 বার
+ blocking MQTT send  : সবচেয়ে বেশি  415.0 ms, গড়  90.6 ms, 50 ms-এর বেশি দেরি 3289/9000 বার

তিনটি কাজের loop একবার ঘুরতে 3 + 12 + 0.1 = 15.1 ms লাগে, তাই সবচেয়ে খারাপ সাড়া ঠিক এক loop: button-টি দেখার ঠিক পরেই চাপলে পরের পালা পর্যন্ত অপেক্ষা। গড় তার অর্ধেক, 7.5 ms. Blocking পাঠানো যোগ হতেই worst case প্রায় 400 + 15 = 415 ms, আর ৯০০০টি চাপের মধ্যে ৩২৮৯টি (প্রায় ৩৭ শতাংশ) 50 ms-এর বেশি দেরি পায়: ক্রেতা বোতাম চেপে ভাববেন যন্ত্রটি নষ্ট। গড় (90.6 ms) সমস্যার আসল চেহারা দেখায় না; real-time-এ worst case দেখতে হয়। সমাধান: পাঠানোর কাজ ছোট ছোট non-blocking ধাপে ভাগ করা (অনুশীলন ৪), interrupt ব্যবহার (পর্ব ৪৩), অথবা RTOS-এ আলাদা task (পর্ব ৫৬)। Super loop আর state machine-এর পূর্ণ নকশা পর্ব ৫৫-এ।

Super loop-এর ভেতরে “অপেক্ষা করে থাকা” কোড (delay(500), network-এর উত্তরের জন্য loop, UART-এ পুরো বার্তা আসা পর্যন্ত বসে থাকা) সবচেয়ে সাধারণ real-time বাগ। Desktop-এ এগুলো নিরীহ; এমবেডেড যন্ত্রে এগুলোই button মিস, alarm দেরি আর watchdog reset-এর কারণ।

৬ · নির্ভরযোগ্যতা — ভুল হবেই, ধরে ফেলুন আর ফিরে আসুন

Reliability বা নির্ভরযোগ্যতা মানে নির্দিষ্ট সময় ধরে, নির্দিষ্ট পরিবেশে ঠিকভাবে কাজ করে যাওয়ার সম্ভাবনা। একে প্রায়ই MTBF (দুটি ব্যর্থতার মাঝের গড় সময়) দিয়ে প্রকাশ করা হয়। এমবেডেড যন্ত্রে ব্যর্থতার উৎস অনেক: firmware-এর বাগে আটকে যাওয়া, voltage ক্ষণিক নেমে যাওয়া (brown-out), মোটর বা relay-র বৈদ্যুতিক noise, sensor-এর তার আলগা হওয়া। ল্যাপটপে সমাধান “restart”; দেয়ালের মিটারে সেই মানুষটি নেই। তাই এমবেডেড নকশার মূলমন্ত্র: ভুল ঘটবে ধরে নিন; সেটি ধরে ফেলার আর নিরাপদে ফিরে আসার পথ আগেই বানিয়ে রাখুন।

Watchdog — পাহারাদার timer

রাতের পাহারাদারের বাঁশি না শুনলে বোঝা যায় কিছু গোলমাল। Watchdog timer একই যুক্তিতে চলে: একটি hardware counter নিচের দিকে গোনে, আর firmware-কে নিয়মিত তাকে “খাওয়াতে” (kick বা reload) হয়। Firmware আটকে গেলে kick বন্ধ, counter শূন্যে পৌঁছায়, আর hardware পুরো chip reset করে দেয়। Reference lab-এর watchdog.c ঠিক এই গল্পটি অভিনয় করে: 100 ms timeout, ৫ বার kick, তারপর একটি “বাগ”-এ চিরকালের loop. সত্যিকারের run (BG-M3 board, Clang 22.1.8):

~/lab/_ref $ python -B board.py run firmware/build/watchdog.elf
[     0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[     0.0403 ms] UART: boot #1, reset cause: POWER-ON
[     0.0425 ms] watchdog started, timeout 100 ms
[    20.0556 ms] UART: kick 1
[    40.0555 ms] UART: kick 2
[    60.0556 ms] UART: kick 3
[    80.0555 ms] UART: kick 4
[   100.0556 ms] UART: kick 5
[   100.0846 ms] UART: bug: stuck in a loop, no more kicks
[   200.0431 ms] RESET (watchdog timeout)
[   200.0816 ms] UART: boot #2, reset cause: WATCHDOG
[   200.1069 ms] UART: recovered: entering safe state
[   200.1078 ms] exit(0) after 1600862 cycles
Board-এর অবস্থা (সত্যিকারের run থেকে)
সময় (ms)
boot_count
Watchdog
RCC→CSR
Firmware
  1. প্রথম চালু। Firmware প্রথমে reset-এর কারণ পড়ে: RCC-এর CSR register-এ power-on আর pin reset-এর flag. SRAM-এ একটি “magic” সংখ্যা মেলেনি, তাই এটি প্রথম চালু: boot_count = 1. এই চলক .noinit অংশে, যা startup code মোছে না।
  2. Watchdog চালু। KR = 0x5555 দিয়ে তালা খুলে RLR = 100 (100 ms), তারপর KR = 0xCCCC: watchdog চালু, এবং এখন আর বন্ধ করা যায় না। এটি ইচ্ছাকৃত: কোনো বাগ যেন পাহারাদারকেই ঘুম পাড়াতে না পারে।
  3. নিয়মিত kick. প্রতি 20 ms কাজের পর KR = 0xAAAA: counter আবার 100 ms থেকে গোনা শুরু করে। যতক্ষণ kick আসছে, watchdog চুপ।
  4. শেষ kick. 100.0556 ms-এ ৫ম kick (মাঝে 40, 60, 80 ms-এ আরও তিনটি)। এরপর থেকে যা ঘটবে, তা firmware-এর হাতে নেই।
  5. বাগ: আটকে যাওয়া। Firmware একটি অসীম loop-এ ঢুকল (for (;;) { })। বাস্তবে এটি হতে পারে কোনো sensor-এর উত্তরের জন্য চিরকাল অপেক্ষা, বা কোনো ভুল শর্ত। CPU ব্যস্ত, কিন্তু কোনো কাজ হচ্ছে না।
  6. Watchdog reset. শেষ kick-এর প্রায় 100 ms পরে, 200.0431 ms-এ counter শূন্য: পুরো chip reset. Peripheral-গুলো শুরুর অবস্থায় ফিরল, কিন্তু SRAM-এর .noinit অংশ রয়ে গেল, আর CSR-এ বসল IWDGRSTF flag.
  7. দ্বিতীয় boot. Magic সংখ্যা মিলল, তাই boot_count বেড়ে 2. CSR পড়ে firmware জানল কারণটি WATCHDOG. এই তথ্য লগে রাখা বা server-এ পাঠানো খুব মূল্যবান: মাঠে কোন যন্ত্র কতবার আটকাচ্ছে, তা জানা যায়।
  8. নিরাপদ অবস্থা। কারণ জেনে firmware সাবধানী পথ নিল: recovered: entering safe state. বাস্তবের cold-room monitor-এ এর মানে হতে পারে alarm-এর পূর্ণ পরীক্ষা চালানো আর “একবার reset হয়েছে” বার্তা পাঠানো। Watchdog আর fault handling-এর বিস্তারিত পর্ব ৬১-এ।

এই board-এর watchdog-এর আচরণ reference lab-এর Spec decision 28 মেনে চলে: counter 1 kHz-এ চলে, timeout = RLR ms, 0x5555 ছাড়া RLR লেখা যায় না, 0xCCCC চালু করে এবং আর বন্ধ হয় না। আর SRAM যে watchdog reset-এর পরেও থাকে, তা Spec decision 18. মনে রাখুন, BG-M3-এর সময়ের হিসাব আসল chip-এর নয় (Spec decision 17: এখানে ১টি নির্দেশ = ১টি cycle); আসল chip-এর সময় datasheet থেকে নিতে হয়।

Sensor-এর ত্রুটি — ভুল সংখ্যাকে সত্যি ভাবা

Watchdog শুধু আটকে যাওয়া ধরে; firmware যদি দিব্যি চলে আর ভুল তথ্যকে সত্যি ভাবে? Cold-room sensor I2C bus-এ ঠিকানা 0x48-এ সাড়া দেয়। তার ছিঁড়লে বা ঠিকানা ভুল হলে sensor সাড়া দেয় না, যাকে বলে NACK, আর এই board-এ তখন DATA register-এ আসে 0xFFFF (Spec decision 26; বাস্তবের I2C-তেও লাইন pull-up-এর কারণে প্রায়ই সব bit 1 পড়া যায়)। এখন 0xFFFF-কে তাপমাত্রা হিসেবে পড়লে কী দাঁড়ায়? নিচে sensor-এর format (12-bit two's complement, 0.0625 °C প্রতি LSB, বাঁ-ঘেঁষা) অনুযায়ী কয়েকটি raw মান রূপান্তর করে একটি plausibility check চালানো হয়েছে:

# cold-room sensor-এর 16-bit raw মান -> °C (TMP102-এর মতো: 12-bit, 0.0625 °C/LSB)
def to_t16(raw):
    signed = raw - 0x10000 if raw & 0x8000 else raw   # int16_t হিসেবে পড়া
    return signed >> 4                                # বাঁ-ঘেঁষা 12 bit

def plausible(t16, last_t16):
    if not -40 * 16 <= t16 <= 60 * 16:                # cold room-এ অসম্ভব মান?
        return "বাতিল: সীমার বাইরে"
    if abs(t16 - last_t16) > 2 * 16:                  # 1 s-এ 2 °C-এর বেশি লাফ?
        return "সন্দেহজনক: হঠাৎ লাফ"
    return "গ্রহণযোগ্য"

# (এখনকার raw, আগের সেকেন্ডের raw, কী ঘটেছে)
cases = [(0x0400, 0x03F0, "স্বাভাবিক, 4.00 °C"),
         (0xFF80, 0x0000, "একটু ঠান্ডা, -0.50 °C"),
         (0x7FF0, 0x0400, "সবচেয়ে বড় 12-bit মান"),
         (0xFFFF, 0x0400, "NACK, আগে ছিল 4.00 °C"),
         (0xFFFF, 0x0000, "NACK, আগে ছিল 0.00 °C")]
for raw, prev, what in cases:
    t16 = to_t16(raw)
    verdict = plausible(t16, to_t16(prev))
    print(f"0x{raw:04X} -> t16={t16:5d} -> {t16 / 16:+9.4f} °C  {verdict:20} | {what}")

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

0x0400 -> t16=   64 ->   +4.0000 °C  গ্রহণযোগ্য           | স্বাভাবিক, 4.00 °C
0xFF80 -> t16=   -8 ->   -0.5000 °C  গ্রহণযোগ্য           | একটু ঠান্ডা, -0.50 °C
0x7FF0 -> t16= 2047 -> +127.9375 °C  বাতিল: সীমার বাইরে   | সবচেয়ে বড় 12-bit মান
0xFFFF -> t16=   -1 ->   -0.0625 °C  সন্দেহজনক: হঠাৎ লাফ  | NACK, আগে ছিল 4.00 °C
0xFFFF -> t16=   -1 ->   -0.0625 °C  গ্রহণযোগ্য           | NACK, আগে ছিল 0.00 °C

0x0400 আর 0xFF80 README-র মানের সঙ্গে মেলে (4.00 °C আর −0.50 °C). বিপদটা শেষ দুই সারিতে। 0xFFFF হয়ে যায় t16 = −1, অর্থাৎ −0.0625 °C: একদম বিশ্বাসযোগ্য একটি cold-room তাপমাত্রা! পরিসরের পরীক্ষা এটি ধরতে পারে না। হঠাৎ লাফের পরীক্ষা ধরে, কিন্তু শুধু তখনই যখন আগের পড়া দূরে ছিল; ঘর আগে থেকেই 0 °C-এর কাছে থাকলে ভুলটি “গ্রহণযোগ্য” হয়ে যায়। শিক্ষা: মানের যাচাই দরকার, কিন্তু যথেষ্ট নয়; bus-এর নিজের অবস্থা (ACK না NACK) পড়তেই হবে। I2C-র ACK/NACK পর্ব ৫১-এ।

এবার একই ঘটনা আসল firmware-এ। Reference coldroom.c-কে নিজের lab-এ কপি করে sensor-এর ঠিকানা ইচ্ছা করে 0x49 বানানো হলো (ভুল তার বা ভুল ঠিকানার নকল), পড়ার সংখ্যা ৫টিতে নামানো হলো, আর তিনটি রূপ বানানো হলো: (০) NACK না দেখা, (১) reference-এর মতো NACK দেখে শুধু বার্তা দেওয়া, (২) পরপর ৩টি NACK-এ alarm বাজানো। ঘরের আসল তাপমাত্রা 4.00 °C, সম্পূর্ণ স্বাভাবিক। সত্যিকারের run:

~/lab/_ref $ python -B board.py run ../charac/build/fault0.elf --script ../charac/fw/t4.json
[     0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[     0.0000 ms] > cold-room temperature: +4.00 C
[  1000.0348 ms] UART: t=1 s T=-0.06 C
[  2000.0348 ms] UART: t=2 s T=-0.06 C
[  3000.0347 ms] UART: t=3 s T=-0.06 C
[  3000.0376 ms] GPIO PA6 ALARM ON
[  3000.0611 ms] UART: ALARM ON: LOW temperature
...
~/lab/_ref $ python -B board.py run ../charac/build/fault2.elf --script ../charac/fw/t4.json
[     0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[     0.0000 ms] > cold-room temperature: +4.00 C
[  1000.0184 ms] UART: sensor NACK
[  2000.0184 ms] UART: sensor NACK
[  3000.0184 ms] UART: sensor NACK
[  3000.0201 ms] GPIO PA6 ALARM ON
[  3000.0414 ms] UART: ALARM ON: SENSOR FAULT
...

রূপ (০) ঘর ঠিক থাকা সত্ত্বেও “LOW temperature” বলে মিথ্যা alarm দেয় (C-তে −1 × 25 / 4 = −6, অর্থাৎ ডিগ্রির শততম ভাগে −0.06). রূপ (১)-এ শুধু পাঁচ লাইন sensor NACK, alarm বাজে না: আরও বিপজ্জনক, কারণ তখন ঘর সত্যিই গরম হলেও কেউ জানবে না। রূপ (২) ঠিক কাজটি করে: সমস্যাটির নাম দিয়ে alarm বাজায়। এটিই fail-safe নকশা: নিজের অবস্থা না জানলে যন্ত্র নিরাপদ দিক বেছে নেয়, এখানে মানুষকে ডাকা। (রূপ (২)-এর কোড অনুশীলন ১-এর উত্তরে।)

৭ · Safety আর দীর্ঘ আয়ু — যখন ভুলের দাম অনেক বেশি

নির্ভরযোগ্যতা আর নিরাপত্তা (safety) এক জিনিস নয়। নির্ভরযোগ্যতা প্রশ্ন করে, “যন্ত্রটি কতক্ষণ ঠিকভাবে কাজ করে?” Safety প্রশ্ন করে, “কাজ না করলে কারও ক্ষতি হয় কি?” যে চার্জার কখনো বন্ধ হয় না, এমনকি ব্যাটারি অতিরিক্ত গরম হলেও, সে নির্ভরযোগ্য কিন্তু অনিরাপদ। আবার নিরাপত্তার জন্য নিজেকে থামানো যন্ত্র নির্ভরযোগ্যতা হারায়, safety পায়। যে শাখা এই ঝুঁকি মাপে আর প্রমাণসহ কমায়, তার নাম functional safety.

Fail-safe

ব্যর্থ হলে নিরাপদ অবস্থায় থামা। চার্জার: সন্দেহ হলে charging বন্ধ। সেলাই মেশিন: মোটর থামানো।

থামাই নিরাপদ

Fail-operational

ব্যর্থতার পরেও জরুরি কাজটি চালু রাখা, প্রায়ই দ্বিগুণ hardware দিয়ে। উড়োজাহাজের নিয়ন্ত্রণে থামা কোনো বিকল্প নয়।

থামা অসম্ভব

Graceful degradation

কিছু অংশ গেলে কম সুবিধায় চলা। Network না থাকলে cold-room monitor তবুও স্থানীয় alarm বাজায়।

কমে, থামে না

যে যন্ত্রে প্রাণের ঝুঁকি আছে, সেখানে নকশা আর প্রমাণের পদ্ধতি আন্তর্জাতিক মানদণ্ডে বাঁধা। সাধারণ মানদণ্ড IEC 61508 (১৯৯০-এর দশকের শেষে প্রকাশিত), গাড়ির জন্য ISO 26262 (প্রথম সংস্করণ ২০১১), চিকিৎসা-যন্ত্রের software-এর জন্য IEC 62304. এগুলো বলে না “কোন কোড লিখবেন”; বলে ঝুঁকি কীভাবে বিশ্লেষণ করবেন, প্রতিটি requirement কীভাবে test-এর সঙ্গে জুড়বেন, আর কাজ যে ঠিক হয়েছে তার কী প্রমাণ রাখবেন। এই কোর্সের পর্ব ৬৩ এদের সঙ্গে MISRA C-এর নিয়মও দেখাবে।

দীর্ঘ আয়ুর লুকানো ফাঁদ

একটি স্মার্ট মিটার দশ বছর চলতে পারে। দীর্ঘ আয়ু নিজেই কিছু নতুন সমস্যা আনে:

  • Counter উপচে পড়া: reference watchdog.c-এ millisecond গোনার চলক uint32_t ms_ticks. 232 ms ≈ 49.7 দিন পরে এটি আবার 0-তে ফেরে। Reference কোড অপেক্ষার শর্ত লিখেছে (ms_ticks - start) < ms: unsigned বিয়োগ wrap-এর পরেও ঠিক ফল দেয় (যেমন start = 0xFFFFFFF0, এখন 0x20 হলে পার্থক্য 48). কিন্তু ms_ticks >= start + ms লিখলে প্রায় ৫০ দিন পরে যন্ত্রটি অদ্ভুত আচরণ করবে, পরীক্ষাগারের এক সপ্তাহের test-এ যা কখনো ধরা পড়বে না।
  • Firmware update: বছরের মাঝে বাগ বা নিরাপত্তা-ত্রুটি পাওয়া যাবে। OTA update সুবিধা দেয়, কিন্তু update-এর মাঝপথে বিদ্যুৎ গেলে যন্ত্র অচল হতে পারে; তাই দুই-কপি firmware আর যাচাই (পর্ব ৭৫, ৭৭)।
  • যন্ত্রাংশ বন্ধ হওয়া: দশ বছরে কোনো chip-মডেলের উৎপাদন বন্ধ হতে পারে, তাই দীর্ঘমেয়াদি সরবরাহের প্রতিশ্রুতিওয়ালা chip বাছা হয়।

আরও গভীরে: নিরাপত্তা-সংবেদনশীল কাজের জন্য তৈরি কিছু microcontroller-এ দুটি CPU core একই নির্দেশ একসাথে চালায়, আর একটি তুলনাকারী প্রতিটি cycle-এ দুজনের ফল মেলায় (lockstep); অমিল মানেই hardware ত্রুটি। ARM-এর Cortex-R পরিবারে এমন lockstep বিন্যাসের ব্যবস্থা আছে। অনেক chip-এ SRAM আর flash-এ ECC (error-correcting code) থাকে, যা মহাজাগতিক রশ্মি বা বৈদ্যুতিক noise-এ উল্টে যাওয়া একটি bit নিজেই ঠিক করে। আর IEC 61508 ঝুঁকির মাপে চারটি safety integrity level (SIL 1–4) রেখেছে; যত উঁচু level, তত কম ব্যর্থতার সম্ভাবনা প্রমাণ করতে হয়, আর তত কঠোর পদ্ধতি মানতে হয়।

৮ · Firmware বনাম software, আর এমবেডেড development cycle

এমবেডেড যন্ত্রের program-কে বলা হয় firmware: “firm” কারণ এটি hardware আর software-এর মাঝামাঝি, chip-এর flash-এ স্থায়ীভাবে বসানো, যন্ত্র চালু হওয়া মাত্র চলে। ল্যাপটপের app-এর সঙ্গে পার্থক্যগুলো:

দিকApplication softwareFirmware
কোথায় থাকেDisk-এ ফাইল, OS খুলে চালায়Chip-এর flash-এ, reset-এর পরেই চলে
নিচে কী আছেOS: memory, ফাইল, network সব দেয়প্রায়ই কিছুই না (bare-metal), বা ছোট RTOS
Hardware-এর সঙ্গেDriver-এর আড়ালেসরাসরি register পড়ে-লেখে
শেষ হয় কখনব্যবহারকারী বন্ধ করলেকখনো না; main থেকে ফেরা মানেই বাগ
Build হয় কোথায়যে যন্ত্রে চলবে সেখানেইঅন্য যন্ত্রে, cross-compiler দিয়ে
Updateঘনঘন, সহজকদাচিৎ, ঝুঁকিপূর্ণ, যাচাই লাগে

এই পর্বের প্রতিটি run-এ একটি cross-compiler কাজ করেছে: ল্যাপটপে চলা Clang বানিয়েছে Cortex-M3-এর thumbv7m নির্দেশ। Embedded C-এর ভিত্তি C কোর্সের পর্ব ৫৪-এ। এখন পুরো development cycle ধাপে ধাপে:

  1. Requirementসংখ্যায় constraint
  2. HardwareMCU, sensor বাছাই
  3. FirmwareC + cross-compile
  4. Host-এ testsimulator
  5. Board-এflash, debug
  6. HIL, উৎপাদনsystem test
  7. মাঠেupdate, লগ
  1. Requirement আর constraint. অংশ ৪-এর টেবিল: কী করবে, কত সময়ে, কত শক্তিতে, কত memory-তে, ব্যর্থ হলে কী করবে। এখানকার প্রতিটি সংখ্যা পরে একটি test হবে।
  2. Hardware বাছাই, firmware-এর সঙ্গে মিলিয়ে। কোন microcontroller, কোন sensor, কোন bus. এখানে hardware আর software একসাথে ভাবতে হয় (co-design): দ্রুত একটি ADC কিনলে firmware সহজ হয়, ধীর chip নিলে firmware-কে চালাক হতে হয়। কোন chip কোন কাজে, তা পর্ব ০৩ আর পর্ব ২৮-এ।
  3. Firmware লেখা আর cross-compile. C-তে কোড, তারপর ল্যাপটপে বসে target chip-এর জন্য build: compiler, linker script, map ফাইল। এই পর্বের 1848 byte-এর হিসাব এই ধাপের ফল। বিস্তারিত পর্ব ৩৭-এ।
  4. Host-এ test আর simulation. Hardware আসার আগেই যুক্তি যাচাই: দামের সূত্র, sensor-এর রূপান্তর ব্রাউজারে, পুরো firmware virtual board-এ। এই পর্বের সব run এই ধাপে। পর্ব ৬৪-এ unit test আর simulation.
  5. আসল board-এ flash আর debug. Programmer দিয়ে firmware chip-এ লেখা, তারপর SWD বা JTAG দিয়ে চলন্ত chip-এ breakpoint, register দেখা, logic analyzer-এ সংকেত মাপা (পর্ব ৩৮)। এখানে আসল সময়, আসল noise, আসল বিদ্যুৎ খরচ প্রথম দেখা দেয়।
  6. HIL test আর উৎপাদন। Hardware-in-the-loop: আসল controller-কে একটি কম্পিউটারের সঙ্গে জোড়া হয়, যা sensor আর পরিবেশের নকল সংকেত দেয়: তাপমাত্রা হঠাৎ বাড়ানো, sensor-এর তার “ছিঁড়ে” দেওয়া। তারপর উৎপাদনে প্রতিটি ইউনিটের দ্রুত পরীক্ষা। Testing-এর স্তর আর V-model Software Testing কোর্সের পর্ব ০৪-এ।
  7. মাঠে: পর্যবেক্ষণ আর update. বিক্রির পরেও চক্র শেষ নয়: reset-এর কারণ আর ত্রুটির লগ সংগ্রহ, নিরাপদ OTA update. মাঠের তথ্য থেকে নতুন requirement জন্মায়, চক্র আবার শুরু হয়।

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

  • এমবেডেড সিস্টেমের চারটি বৈশিষ্ট্য লিখুন। নির্দিষ্ট কাজ; সীমিত সম্পদ (memory, শক্তি, খরচ); real-time আচরণ; উচ্চ নির্ভরযোগ্যতা আর দীর্ঘ আয়ু (সঙ্গে প্রায়ই safety).
  • Hard আর soft real-time-এর পার্থক্য উদাহরণসহ। Hard-এ একবার deadline পেরোনোই ব্যর্থতা (airbag); soft-এ শুধু মান কমে (ভিডিও কল)।
  • Watchdog timer কী আর কেন? Firmware আটকে গেলে নিয়মিত kick বন্ধ হয়, hardware counter শূন্যে পৌঁছে chip reset করে।
  • Watchdog-কে timer interrupt থেকে kick করা কেন ভুল? Main loop আটকে থাকলেও interrupt চলে, তাই watchdog কখনো reset করে না (অনুশীলন ২-এ সত্যিকারের run).
  • Firmware আর software-এর পার্থক্য। Firmware flash-এ স্থায়ী, reset থেকেই চলে, hardware-এর register সরাসরি নিয়ন্ত্রণ করে, cross-compile হয়, update বিরল ও ঝুঁকিপূর্ণ।

৯ · AI-এর যুগে এমবেডেড নকশা

AI assistant-কে একটি তাপমাত্রা alarm-এর কোড চাইলে কয়েক সেকেন্ডেই compile হওয়ার মতো কোড আসে। কিন্তু এই পর্বের প্রতিটি বৈশিষ্ট্যেই AI চুপচাপ ভুল করতে পারে: সে আপনার chip-এর memory, deadline বা ব্যর্থতার পথ জানে না। এমবেডেড বাগ desktop বাগের মতো তাৎক্ষণিক crash দেয় না; সে ৫০ দিন পরে, লোডশেডিংয়ের রাতে, বা sensor-এর তার আলগা হলে দেখা দেয়।

AI প্রায়ই যা করেকেন বিপজ্জনকযেভাবে ধরবেন
Loop-এ delay() আর blocking network callButton মিস, alarm দেরি (অংশ ৫-এর 415 ms)প্রতিটি কাজের WCET যোগ করে worst case হিসাব
16-bit chip-এ int-এ বড় গুণচুপচাপ ভুল দাম (অংশ ২)প্রতিটি মধ্যবর্তী মানের সর্বোচ্চ মাপ হাতে হিসাব
I2C-র NACK বা error code উপেক্ষামিথ্যা alarm বা নীরব ব্যর্থতা (অংশ ৬)Simulator-এ sensor “খুলে” চালানো
Watchdog timer interrupt থেকে kickআটকে গেলেও reset হয় নাইচ্ছা করে hang ঢুকিয়ে test
কোনো chip-এর জন্য বানানো register নাম বা ঠিকানাCompile হয় না, বা ভুল register-এ লেখেDatasheet আর reference manual মিলিয়ে দেখা
Wi-Fi password আর key কোডে বসানো, TLS ছাড়াএকটি যন্ত্র খুললেই সবগুলোর চাবি ফাঁসSecurity checklist (পর্ব ৭৬)

AI-কে এমবেডেড কোড চাইলে constraint-গুলো আগেই বলে দিন, আর উত্তরে প্রমাণ চান। নিচের কাঠামোটি কপি করে নিজের যন্ত্রের সংখ্যা বসিয়ে নিন:

আমি একটি cold-storage temperature monitor-এর firmware লিখছি। Constraint: - MCU: ARM Cortex-M3, 8 MHz, 128 KiB flash, 20 KiB SRAM, FPU নেই; heap আর printf ব্যবহার করা যাবে না। - I2C sensor ঠিকানা 0x48, 12-bit two's complement, 0.0625 °C/LSB. - প্রতি 1 s-এ পড়া; 8.00 °C-এর ওপরে বা 0.00 °C-এর নিচে পরপর ৩ বার হলে alarm; 0.50 °C hysteresis. - Super loop, কোনো blocking delay নয়; watchdog 100 ms. তুমি C-তে main loop লেখো। তারপর আলাদা করে বলো: ১. Loop-এর প্রতিটি কাজের সম্ভাব্য সবচেয়ে বেশি সময় আর worst-case loop সময়। ২. Sensor NACK দিলে, বা পরপর ৩ বার ব্যর্থ হলে কী হবে। ৩. কোন কোন জায়গায় integer overflow বা millisecond counter-এর wrap সম্ভব। ৪. Watchdog কোথায় kick হচ্ছে, আর কেন সেখানে। কোনো register নাম বা ঠিকানা অনুমানে লিখবে না; না জানলে বলবে যে datasheet দেখতে হবে।

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

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

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

প্র ০১প্রথম microprocessor কেন একটি ক্যালকুলেটরের জন্য তৈরি হলো, কম্পিউটারের জন্য নয়? এমবেডেড সিস্টেমের ইতিহাসে এর মানে কী?

১৯৬০-এর দশকের শেষে প্রতিটি ইলেকট্রনিক যন্ত্রের জন্য আলাদা নকশার chip বানানো হতো: একটি ক্যালকুলেটরের জন্য এক সেট নির্দিষ্ট লজিক chip, আরেকটি মডেলের জন্য আরেক সেট। একটি জাপানি ক্যালকুলেটর-নির্মাতা যখন Intel-এর কাছে কয়েকটি বিশেষ chip চাইল, Intel-এর প্রকৌশলীরা প্রস্তাব দিলেন ভিন্ন পথ: একটি সাধারণ, programmable processor আর তার ROM-এ রাখা program. বিভিন্ন মডেলের পার্থক্য তখন hardware-এ নয়, program-এ। এভাবে ১৯৭১ সালে এলো 4004.

এই সিদ্ধান্তের অর্থনীতি আজও এমবেডেড জগতের ভিত্তি। একটি নির্দিষ্ট chip (আজকের ভাষায় ASIC) একটি কাজে সবচেয়ে দক্ষ, কিন্তু নকশা ব্যয়বহুল আর বদলানো প্রায় অসম্ভব। একটি সাধারণ processor কাজটি হয়তো কম দক্ষভাবে করে, কিন্তু একই chip লাখো ভিন্ন পণ্যে চলে, ফলে প্রতিটির খরচ কমে, আর ভুল হলে শুধু program বদলালেই চলে। তারও আগে Apollo-র guidance computer দেখিয়েছিল যে একটি ছোট, নির্দিষ্ট কাজের কম্পিউটার কঠোর ওজন, শক্তি আর নির্ভরযোগ্যতার সীমায় কাজ করতে পারে; সেটি প্রায়ই প্রথম দিকের এমবেডেড কম্পিউটারগুলোর একটি হিসেবে গণ্য হয়।

লক্ষ করুন, “general-purpose” chip দিয়ে বানানো হলেও যন্ত্রটি general-purpose নয়। Cold-storage monitor-এর Cortex-M3 তাত্ত্বিকভাবে যেকোনো program চালাতে পারত, কিন্তু তার flash-এ একটিই program, আর ব্যবহারকারী সেটি বদলাতে পারেন না। এমবেডেড হওয়া chip-এর গুণ নয়, পুরো সিস্টেমের ভূমিকার গুণ। আজও এই টানাপোড়েন আছে: খুব বেশি পরিমাণে বানানো বা খুব কম শক্তির কাজে (যেমন কিছু ঘড়ি বা খেলনা) নির্দিষ্ট chip জেতে; বেশিরভাগ ক্ষেত্রে একটি সস্তা microcontroller আর firmware জেতে, কারণ পণ্য বাজারে আনার সময় কম লাগে।

মূল উপলব্ধি: এমবেডেড সিস্টেম মানে “hardware-এর কাজ software দিয়ে করানো”। এতে নমনীয়তা আসে, কিন্তু hardware-এর মতো নির্ভরযোগ্যতার দায়ও software-এর কাঁধে আসে।

প্র ০২একটি রকেট ১৬-bit-এর একটি ঘরের জন্য ধ্বংস হয়েছিল। পুরোনো, প্রমাণিত কোড নতুন যন্ত্রে বসালে কী কী সীমা নতুন করে যাচাই করতে হয়?

১৯৯৬ সালের ৪ জুন ইউরোপের Ariane 5 রকেটের প্রথম উড্ডয়ন প্রায় ৪০ সেকেন্ডের মাথায় পথ হারিয়ে ভেঙে পড়ে। তদন্ত-বোর্ডের প্রতিবেদন কারণটি খুঁজে পায় inertial reference system-এর software-এ: একটি 64-bit floating-point মান (রকেটের অনুভূমিক বেগ-সংক্রান্ত একটি রাশি) 16-bit signed integer-এ রূপান্তরের সময় সেটি ঘরে আঁটেনি। Overflow-এ একটি exception হলো, যন্ত্রটি বন্ধ হলো; একই software-এ চলা দ্বিতীয় (backup) যন্ত্রটিও ঠিক একই কারণে আগেই বন্ধ হয়েছিল।

সবচেয়ে শিক্ষণীয় অংশ: কোডটি নতুন ছিল না। এটি আগের Ariane 4 থেকে নেওয়া, যেখানে বছরের পর বছর নির্ভুল চলেছে। কিন্তু Ariane 5 বেশি দ্রুত ওঠে, তাই সেই রাশিটির মান Ariane 4-এর তুলনায় অনেক বড় হয়। 16-bit যথেষ্ট, এই অনুমান Ariane 4-এর উড্ডয়ন-পথের জন্য সত্য ছিল, নতুন রকেটের জন্য নয়। প্রতিবেদন অনুযায়ী আরও দুঃখজনক তথ্য হলো, যে কাজের জন্য এই হিসাব, সেটি উড্ডয়নের পরে আর দরকারই ছিল না।

এই পর্বের 16-bit দামের ভুলের সঙ্গে মিলটা দেখুন: 9 g পর্যন্ত সব ঠিক, 10 g থেকে ভুল। পরীক্ষার ইনপুট যদি সব ছোট হয়, বাগটি লুকিয়ে থাকে। পুরোনো কোড নতুন যন্ত্রে নিলে প্রশ্নগুলো হলো: প্রতিটি চলকের সর্বোচ্চ মান কি নতুন যন্ত্রে বদলেছে? Clock বা sampling হার বদলালে সময়ের counter কি দ্রুত উপচে পড়বে? নতুন chip-এ int কত bit? আগের নকশার লিখিত অনুমানগুলো (যেমন “এই মান কখনো 32767 পেরোবে না”) কোথায় লেখা, আর কে আবার যাচাই করল?

আজকের নকশায় এজন্য অনুমানগুলো কোডেই লেখা হয়: compile-এর সময়ের পরীক্ষা (_Static_assert), চলার সময়ের পরিসর-পরীক্ষা, আর overflow-এ নিরাপদ আচরণ (saturate করা বা ত্রুটি জানানো, যন্ত্র বন্ধ না করে)।

মূল উপলব্ধি: প্রমাণিত কোড শুধু তার পুরোনো constraint-এর ভেতরে প্রমাণিত। Constraint বদলালে প্রমাণও নতুন করে লাগে।

প্র ০৩একটি যন্ত্র যত বেশি সময় না থেমে চলে, তার সময়ের হিসাব তত ভুল হতে পারে কেন? দীর্ঘ আয়ুর যন্ত্রে সময় কীভাবে গুনবেন?

১৯৯১ সালের ২৫ ফেব্রুয়ারি সৌদি আরবের Dhahran-এ একটি Patriot ক্ষেপণাস্ত্র-প্রতিরক্ষা ব্যবস্থা একটি আগত Scud ক্ষেপণাস্ত্র আটকাতে ব্যর্থ হয়; ২৮ জন সৈন্য নিহত হন। পরের বছর মার্কিন সরকারের হিসাব-নিরীক্ষা সংস্থা GAO-র প্রতিবেদন কারণটি ব্যাখ্যা করে। ব্যবস্থাটি সময় গুনত এক সেকেন্ডের দশমাংশে, আর 0.1 সংখ্যাটি binary-তে নিখুঁতভাবে লেখা যায় না (যেমন 1/3 দশমিকে 0.333… চলতেই থাকে)। 24-bit-এর fixed-point ঘরে রাখায় প্রতি tick-এ খুব সামান্য ভুল জমত।

সামান্য ভুল, কিন্তু ব্যবস্থাটি টানা প্রায় ১০০ ঘণ্টা চালু ছিল। প্রতিবেদন অনুযায়ী তাতে জমা ভুল দাঁড়ায় প্রায় 0.34 সেকেন্ড, আর সেই সময়ে একটি Scud কয়েকশো মিটার পথ যায়। ফলে ব্যবস্থাটি ভুল জায়গায় লক্ষ্য খুঁজল। নকশার সময় অনুমান ছিল যন্ত্রটি অল্প কয়েক ঘণ্টা চালু থেকে আবার চালু হবে; মাঠে সেটি দিনের পর দিন চলেছিল। সংশোধিত software পৌঁছেছিল ঘটনার পরের দিন।

এই পর্বে দুটি সম্পর্কিত ফাঁদ দেখেছেন। এক, uint32_t millisecond counter প্রায় 49.7 দিনে 0-তে ফেরে; সঠিক তুলনা (now - start, unsigned) লিখলে wrap ক্ষতি করে না, ভুল তুলনা লিখলে প্রায় ৫০ দিন পরে যন্ত্র অদ্ভুত আচরণ করে। দুই, সময় যদি দশমিকের মতো ভগ্নাংশে গোনা হয়, ভুল জমে। নিরাপদ পথ হলো সময় পূর্ণসংখ্যার tick-এ রাখা (বাজারঘরের board-এ SysTick 10 ms, LOAD = 79 999), আর ভগ্নাংশে রূপান্তর শুধু দেখানোর সময়।

দীর্ঘ আয়ুর যন্ত্রের test-এও এটি বদল আনে: পরীক্ষাগারে ৫০ দিন অপেক্ষা না করে counter-কে wrap-এর একটু আগের মানে শুরু করিয়ে test করা হয়। সময়ের ফাঁদগুলো তখন মিনিটেই ধরা পড়ে।

মূল উপলব্ধি: “কতক্ষণ না থেমে চলবে” একটি constraint, আর সেটি লিখে রাখা আর test করা দরকার, ঠিক memory বা শক্তির মতো।

প্র ০৪চাঁদে নামার মুহূর্তে computer বারবার নিজেকে restart করছিল, তবুও অবতরণ সফল হলো। ব্যর্থতা থেকে ফিরে আসার নকশা কেমন হয়?

১৯৬৯ সালের জুলাইয়ে Apollo 11-এর চন্দ্রযান নামার সময় নভোচারীদের সামনে কয়েকবার “1202” আর “1201” alarm জ্বলে ওঠে। এর মানে ছিল guidance computer-এর হাতে যত কাজ জমেছে, তার সবগুলো সময়মতো করার মতো জায়গা বা সময় তার নেই। পরে জানা যায়, একটি radar-এর সংযোগ-বিন্যাসের কারণে computer-এর বাড়তি সময় খরচ হচ্ছিল। MIT-র Instrumentation Laboratory-তে, Margaret Hamilton-এর নেতৃত্বাধীন দলসহ, যাঁরা এই software বানিয়েছিলেন, তাঁরা এমন পরিস্থিতির জন্য আগেই পথ রেখেছিলেন: কাজগুলোর অগ্রাধিকার ঠিক করা ছিল, আর অতিরিক্ত চাপে computer নিজেকে দ্রুত restart করে কম জরুরি কাজ ছেঁটে ফেলে শুধু অবতরণের জন্য জরুরি কাজগুলো চালিয়ে যেত।

এটি ঠিক এই পর্বের দুটি ধারণার যৌথ রূপ। Watchdog-এর মতো, একটি ব্যর্থতা ধরা পড়লে system নিজেই reset হয়, কোনো মানুষের অপেক্ষা না করে। কিন্তু শুধু reset যথেষ্ট নয়: reset-এর পরে কোন অবস্থা থেকে, কোন কাজ নিয়ে শুরু করবে, তা নকশা করা থাকতে হয়। আমাদের watchdog.c-এ .noinit-এ রাখা boot-সংখ্যা আর reset-এর কারণ পড়ে “নিরাপদ অবস্থায়” যাওয়া সেই চিন্তারই ছোট রূপ। Apollo-র ক্ষেত্রে জরুরি অবস্থার তথ্য restart-এর পরেও রক্ষা করা হতো, আর অগ্রাধিকারের নিয়মে graceful degradation হতো।

একই যুগের আরেকটি শিক্ষা পরে আসে ১৯৯৭ সালে, Mars Pathfinder-এ: মঙ্গলে পৌঁছে যানটি বারবার reset হচ্ছিল। কারণ ছিল RTOS-এ priority inversion (পর্ব ৫৭-এ বিস্তারিত), আর watchdog-ধরনের ব্যবস্থাই প্রতিবার system-কে উদ্ধার করছিল; পৃথিবী থেকে একটি সেটিং বদলে সমস্যার সমাধান হয়। দুই ক্ষেত্রেই reset ছিল নিরাপত্তা-জাল, আর মূল কারণ খুঁজে ঠিক করা ছিল আলাদা কাজ।

মূল উপলব্ধি: নির্ভরযোগ্য নকশা মানে ভুল না হওয়া নয়; মানে ভুল ধরা পড়বে, system নিরাপদ ও কাজের অবস্থায় ফিরবে, আর কী ঘটেছিল তার চিহ্ন রেখে যাবে।

প্র ০৫Hardware-এর নিরাপত্তা-তালা সরিয়ে software-এর ওপর ভরসা করলে কী হতে পারে? Safety আর নির্ভরযোগ্যতা আলাদা কেন?

১৯৮৫ থেকে ১৯৮৭ সালের মধ্যে Therac-25 নামের একটি radiation-therapy যন্ত্রে ছয়টি দুর্ঘটনায় রোগীরা নির্ধারিত মাত্রার বহুগুণ বেশি বিকিরণ পান; কয়েকজন মারা যান। ১৯৯৩ সালে Nancy Leveson আর Clark Turner-এর বিস্তারিত বিশ্লেষণ এটিকে software-safety-র সবচেয়ে বেশি পড়ানো ঘটনাগুলোর একটি বানিয়েছে। আগের মডেলগুলোতে বিপজ্জনক অবস্থা আটকাতে hardware interlock (যান্ত্রিক নিরাপত্তা-তালা) ছিল; নতুন মডেলে সেই দায়িত্ব অনেকটা software-কে দেওয়া হয়। Software-এ একটি race condition ছিল: অভিজ্ঞ operator খুব দ্রুত তথ্য সংশোধন করলে যন্ত্রের অবস্থা আর পর্দার তথ্য মিলত না। পর্দায় একটি দুর্বোধ্য error বার্তা আসত, যা operator-রা অভ্যাসবশে উপেক্ষা করে চালিয়ে যেতেন।

লক্ষ করুন, যন্ত্রটি বেশিরভাগ সময় ঠিকঠাক চলত; নির্ভরযোগ্যতার হিসাবে খারাপ দেখাত না। সমস্যা ছিল safety-তে: বিরল একটি পরিস্থিতিতে ব্যর্থতা মারাত্মক ছিল, আর কোনো স্বাধীন দ্বিতীয় স্তর সেটি আটকায়নি। এজন্যই আজকের safety-নকশায় “defense in depth” চলে: software-এর যাচাইয়ের পাশাপাশি স্বাধীন hardware সুরক্ষা (চার্জারে software ছাড়াও thermal fuse), পরিষ্কার error বার্তা, আর নিরাপদ default.

এই ঘটনা আর এমন আরও কিছু ঘটনার পরে চিকিৎসা-যন্ত্রের software-এর জন্য IEC 62304-এর মতো মানদণ্ড আসে, আর সাধারণভাবে IEC 61508. এগুলো দাবি করে: ঝুঁকির বিশ্লেষণ, প্রতিটি safety requirement-এর সঙ্গে test-এর সংযোগ, আর পরিবর্তন হলে আবার প্রমাণ। এই পর্বের fail-safe রূপ (২), যা sensor না পেলে alarm বাজায়, সেই চিন্তার ছোট উদাহরণ: অনিশ্চয়তায় নিরাপদ দিক বেছে নেওয়া।

মূল উপলব্ধি: নির্ভরযোগ্যতা জিজ্ঞেস করে “কত কম ব্যর্থ হয়”; safety জিজ্ঞেস করে “ব্যর্থ হলে কী হয়”। জীবন-ঝুঁকির যন্ত্রে দ্বিতীয় প্রশ্নের উত্তর software-এর একক স্তরের ওপর ছেড়ে দেওয়া যায় না।

অনুশীলন

প্রথমে নিজে চেষ্টা করুন, তারপর উত্তর খুলুন। প্রতিটি উত্তর সত্যিকারের run বা চালানো হিসাব দিয়ে যাচাই করা।

  1. নকশা — fail-safe sensor পড়া: Cold-storage firmware-এর জন্য একটি tsens_read ফাংশন লিখুন, যা NACK পেলে -1 ফেরত দেয়। তারপর main loop-এ এমন যুক্তি লিখুন, যাতে পরপর ৩টি ব্যর্থ পড়ায় alarm চালু হয় আর UART-এ ALARM ON: SENSOR FAULT আসে; একটি সফল পড়া এলে ব্যর্থতার গোনা শূন্যে ফেরে।

    Reference coldroom.c-এর কাঠামো রেখে (register নাম bazarghar.h-এর):

    static int tsens_read(int32_t *t16)
    {
        I2C1->ADDR = TSENS_ADDR;
        I2C1->REG = TSENS_REG_TEMP;
        I2C1->CR = I2C_CR_START;
        while ((I2C1->SR & (I2C_SR_DONE | I2C_SR_NACK)) == 0) { }
        if (I2C1->SR & I2C_SR_NACK)
            return -1;                           /* DATA = 0xFFFF: ব্যবহার নয় */
        *t16 = (int32_t)(int16_t)I2C1->DATA >> 4;
        return 0;
    }
    /* main loop-এর ভেতরে, প্রতি 1 s-এ: */
            if (tsens_read(&t16) != 0) {
                uart_puts("sensor NACK\r\n");
                if (++fails >= CONFIRM && !on) { on = 1; alarm_on("SENSOR FAULT"); }
                continue;
            }
            fails = 0;                           /* একটি ভালো পড়াই যথেষ্ট */

    যাচাই: এই কোড (ঠিকানা ইচ্ছা করে 0x49) virtual board-এ চালানো হয়েছে, আর অংশ ৬-এর fault2.elf-এর আউটপুটটিই এর ফল: 1, 2, 3 s-এ sensor NACK, তারপর 3000.0201 ms-এ GPIO PA6 ALARM ON আর ALARM ON: SENSOR FAULT. while loop-টিও ঝুঁকি: bus কখনো DONE বা NACK না দিলে এখানে আটকে যাবে; আসল chip-এ একটি timeout রাখাই নিরাপদ।

  2. ভুল খুঁজুন — watchdog-এর ভুল জায়গা: এক বন্ধু watchdog.c বদলে kick-টি main loop থেকে সরিয়ে 1 ms-এর SysTick interrupt-এ বসালেন, যুক্তি দিলেন “এভাবে কখনো ভুলে যাব না”:
    void SysTick_Handler(void)
    {
        ms_ticks++;
        IWDG->KR = 0xAAAAu;          /* প্রতি 1 ms-এ kick */
    }
    ৫টি কাজের পরে firmware আগের মতোই for (;;) { }-এ আটকে যায়। কী ঘটবে, আর সমস্যাটা কোথায়?

    Watchdog আর কখনো reset করবে না। Main loop আটকে থাকলেও SysTick interrupt প্রতি 1 ms-এ চলতে থাকে, আর প্রতিবার kick দেয়। সত্যিকারের run (এই পরিবর্তনসহ কপি, 4 000 000 cycle = 500 ms পর্যন্ত):

    [     0.0394 ms] UART: boot #1, reset cause: POWER-ON
    [     0.0419 ms] watchdog started, timeout 100 ms
    [    20.0550 ms] UART: work 1
    ...
    [   100.0550 ms] UART: work 5
    [   100.0727 ms] UART: bug: stuck in a loop
    [   500.0000 ms] stopped: cycle limit (4000000) reached after 4000000 cycles

    আসল watchdog.c 200.0431 ms-এ reset করেছিল; এখানে 500 ms পর্যন্ত কিছুই হয়নি, আর বাস্তবে চিরকাল কিছু হবে না। Watchdog-কে প্রশ্ন করতে হয় “main কাজটি কি এগোচ্ছে?”, অথচ এখানে সে শুধু শুনছে “timer interrupt কি চলছে?” নিয়ম: kick দিন main loop থেকে, প্রতিটি জরুরি কাজ শেষ হয়েছে নিশ্চিত হওয়ার পরে। RTOS-এ প্রায়ই প্রতিটি task একটি “বেঁচে আছি” flag তোলে, আর একটি জায়গা সব flag দেখে তবেই kick দেয় (পর্ব ৬১)।

  3. Output অনুমান — hysteresis: বাজারঘরের cold-storage firmware (প্রতি 1 s-এ পড়া, 8.00 °C-এর ওপরে পরপর ৩টি পড়ায় HIGH alarm, 0.50…7.50 °C-এ পরপর ৩টি পড়ায় বন্ধ) এই তাপমাত্রাগুলো পায়: t = 1, 2 s-এ 8.50 °C; t = 3 s-এ 7.75 °C; t = 4, 5, 6 s-এ 8.50 °C; t = 7 s থেকে 7.25 °C. Alarm কোন সেকেন্ডে চালু হবে, কোন সেকেন্ডে বন্ধ হবে?

    চালু t = 6 s-এ, বন্ধ t = 9 s-এ। t = 1, 2-এ high গোনা 1, 2; t = 3-এর 7.75 °C 8.00-এর বেশি নয়, তাই গোনা শূন্য (7.50-এর বেশি বলে “ভালো” গোনাও শূন্য)। t = 4, 5, 6-এ আবার 1, 2, 3, তাই 6 s-এ alarm. t = 7, 8, 9-এ 7.25 °C ভালো সীমায়, তাই 9 s-এ বন্ধ। Reference coldroom.elf-এ এই script দিয়ে সত্যিকারের run:

    [  2000.0352 ms] UART: t=2 s T=+8.50 C
    [  3000.0352 ms] UART: t=3 s T=+7.75 C
    [  4000.0352 ms] UART: t=4 s T=+8.50 C
    [  5000.0352 ms] UART: t=5 s T=+8.50 C
    [  6000.0352 ms] UART: t=6 s T=+8.50 C
    [  6000.0387 ms] GPIO PA6 ALARM ON
    [  6000.0634 ms] UART: ALARM ON: HIGH temperature
    [  7000.0352 ms] UART: t=7 s T=+7.25 C
    [  8000.0352 ms] UART: t=8 s T=+7.25 C
    [  9000.0353 ms] UART: t=9 s T=+7.25 C
    [  9000.0396 ms] GPIO PA6 ALARM OFF
    [  9000.0489 ms] UART: ALARM OFF

    সাধারণ ভুল: t = 3-এর পরেও high-এর গোনা চালিয়ে যাওয়া; “পরপর” মানে মাঝে একটি ভিন্ন পড়া এলেই গোনা নতুন করে শুরু।

  4. হিসাব — super loop-এর worst case: একটি super loop-এ ওজন পড়া 3 ms, display 12 ms, button দেখা 0.1 ms, আর প্রতি ৪০ বার ঘোরার পর একবার 400 ms-এর blocking MQTT পাঠানো। (ক) Button-এর সবচেয়ে খারাপ সাড়ার সময় কত? (খ) পাঠানোর কাজটিকে প্রতি loop-এ 4 ms-এর একটি non-blocking ধাপে ভাগ করলে নতুন worst case কত? (গ) কোনটি 50 ms deadline মানে?

    (ক) সবচেয়ে খারাপ ঘটনা: button দেখা শুরু হওয়ার ঠিক পরেই চাপ, আর ঠিক তারপরেই blocking পাঠানো। পরের দেখা পর্যন্ত অপেক্ষা = button 0.1 + পাঠানো 400 + ওজন 3 + display 12 = 415.1 ms, অর্থাৎ প্রায় 415 ms (প্রতি পূর্ণ millisecond-এ চাপ ধরে চালানো হিসাবে সর্বোচ্চ এসেছে 415.0 ms). (খ) এখন প্রতিটি loop = 3 + 12 + 0.1 + 4 = 19.1 ms, তাই worst case প্রায় 19.1 ms. (গ) শুধু (খ) 50 ms মানে।

    যাচাই: অংশ ৫-এর superloop_latency.py দিয়েই চালানো হয়েছে। Blocking রূপে worst = 415.0 ms; ("send_step", 4, 1) যোগ করা রূপে worst = 19.1 ms, আর 50 ms-এর বেশি দেরি ৯০০০-এর মধ্যে ০ বার। কাজ কমেনি, শুধু টুকরো হয়েছে।

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

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

ক্রমএমবেডেড development-এর ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. 📋 Requirement-কে মাপা যায় এমন constraint-এ লেখা
  2. 🔌 Microcontroller আর sensor বাছাই
  3. ⚙️ Firmware লেখা আর cross-compile করা
  4. 🧪 Host বা simulator-এ যুক্তি test করা
  5. 🔧 আসল board-এ flash, debug আর HIL test
  6. 📡 উৎপাদন, মাঠে লগ আর নিরাপদ update

নিচের কোনটি একটি এমবেডেড সিস্টেমের সাধারণ বৈশিষ্ট্য নয়?

  • একটি নির্দিষ্ট কাজের জন্য তৈরি
  • সীমিত memory আর শক্তি
  • ব্যবহারকারী নিজে নতুন app বসিয়ে যন্ত্রের কাজ বদলান
  • সময়ের সীমা (deadline) মানা

কোন যন্ত্রটি hard real-time-এর সবচেয়ে ভালো উদাহরণ?

  • ভিডিও কলের অ্যাপ
  • গাড়ির airbag নিয়ন্ত্রক
  • প্রতি 10 সেকেন্ডে পাঠানো তাপমাত্রার telemetry
  • ইমেইল পাঠানোর server

একটি firmware watchdog-কে 1 ms-এর timer interrupt-এর ভেতর থেকে kick করে। Main loop একটি বাগে অসীম loop-এ আটকে গেল। কী ঘটবে?

  • Timeout শেষে watchdog chip reset করবে
  • Timer interrupt-ও থেমে যাবে, তাই reset হবে
  • Watchdog main loop খুঁজে নিয়ে তাকে আবার চালু করবে
  • কোনো reset হবে না; যন্ত্রটি চিরকাল আটকে থাকবে

যে microcontroller-এর compiler-এ unsigned int 16 bit, সেখানে uint16_t g = 150; uint16_t p = g * 6550u; চালালে p-এর মান কত হবে?

  • 982500
  • 64996
  • 983
  • 0

একটি super loop-এ তিনটি কাজ পালাক্রমে চলে: sensor পড়া 3 ms, display 12 ms, button দেখা 0.1 ms. কোনো interrupt নেই। Button চাপার পর সাড়া পেতে সবচেয়ে বেশি কত সময় লাগতে পারে?

  • 0.1 ms
  • 12 ms
  • 15.1 ms
  • 30.2 ms

একটি I2C তাপমাত্রা sensor-এর তার ছিঁড়ে গেছে। Firmware NACK না দেখে DATA register পড়ে, যেখানে আসে 0xFFFF. Sensor-এর format 12-bit two's complement, বাঁ-ঘেঁষা, 0.0625 °C প্রতি LSB. Firmware কোন তাপমাত্রা দেখবে, আর কেন এটি বিপজ্জনক?

  • −0.0625 °C; বিশ্বাসযোগ্য মান, তাই ভুলটি সহজে ধরা পড়ে না
  • +4095.94 °C; এত বড় মান দেখে সহজেই ধরা পড়ে
  • Firmware নিজে থেকেই sensor error দেখাবে
  • 0.00 °C; কারণ ব্যর্থ পড়া সবসময় শূন্য দেয়

শব্দকোষ

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

মনে রাখুন

  1. এমবেডেড সিস্টেম একটি নির্দিষ্ট কাজের কম্পিউটার, বড় যন্ত্রের ভেতরে, বহু বছর, মানুষের তত্ত্বাবধান ছাড়া।
  2. Memory, word size, শক্তি, খরচ, আকার সবই সীমিত; প্রতিটি সীমা সংখ্যায় লিখুন আর map ফাইল, power budget ও worst-case হিসাবে যাচাই করুন।
  3. Real-time মানে নিশ্চিতভাবে সময়মতো, দ্রুত নয়; super loop-এর worst case প্রায় এক loop, আর একটি blocking কাজ সব কাজকে দেরি করায়।
  4. Watchdog আটকে যাওয়া ধরে, plausibility আর NACK পরীক্ষা ভুল তথ্য ধরে, আর fail-safe নকশা অনিশ্চয়তায় নিরাপদ দিকে যায়।
  5. Firmware flash-এ স্থায়ী, reset থেকেই চলে, cross-compile হয়; development cycle requirement থেকে মাঠের update পর্যন্ত একটি চক্র।

পরের পর্বে: এই পর্বে বারবার 0xFFFF, two's complement আর 16-bit-এর ঘর এসেছে। পর্ব ০৫-এ এমবেডেড কাজের সংখ্যার ভাষা হাতে-কলমে: binary, hex, BCD, two's complement, carry বনাম overflow আর fixed-point.

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

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