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

এমবেডেড software testing — host-এ unit test, simulation আর HIL

Embedded Software Testing — Host Unit Tests, Simulation and Hardware-in-the-Loop

Taught in Bangla, this lesson separates pure C rules from a thin register driver so tests run on a PC. Seven host unit tests built with zig cc run 18 checks, and a 7.50 °C boundary test catches a < versus <= bug the full script missed. Fake registers expose an ODR read-modify-write, the same logic runs on the virtual BG-M3 board and the 8085 simulator, and a regression script against expected files catches a price rounding change. It ends with the limits of coverage and static analysis, and hardware-in-the-loop.

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

  • Firmware-কে testable করে নকশা: শুদ্ধ logic, পাতলা driver আর একটি seam
  • Host কম্পিউটারে C unit test লেখা ও চালানো, আর red থেকে green-এর চক্র
  • নকল register দিয়ে driver-এর test, আর তার সীমা
  • Simulator আর virtual board-এ একই কোড চালিয়ে expected file-এর সঙ্গে regression
  • Coverage, compiler warning, static analysis আর HIL: কোনটি কী ধরে, কী ধরে না

১ · Firmware-এর test কেন আলাদা — চার তলার ছবি

একজন দর্জির কথা ভাবুন। পুরো পাঞ্জাবি সেলাইয়ের আগে তিনি মাপের ফিতা দিয়ে প্রতিটি টুকরো মাপেন, তারপর টুকরোগুলো জুড়ে একবার গায়ে পরিয়ে দেখেন, আর শেষে ক্রেতা ঈদের দিনে পরে বের হন। ভুল যত আগে ধরা পড়ে, ঠিক করা তত সস্তা: কাটার আগে মাপের ভুল এক মিনিটের কাজ, ঈদের দিনে সেলাই খোলা বড় ঝামেলা। Firmware-এর test-ও এমন কয়েক তলায় হয়।

Test-এর সাধারণ তত্ত্ব, যেমন test-এর স্তর (unit, integration, system, acceptance) আর test pyramid, সফটওয়্যার টেস্টিং ও QA পর্ব ০৫-এ বিস্তারিত আছে; এখানে শুধু এমবেডেড দিক। Firmware-এর test তিন কারণে কঠিন। প্রথমত, কোড একটি ছোট chip-এ চলে, যেখানে printf বা debugger সবসময় সহজ নয়। দ্বিতীয়ত, কোড hardware-এর ওপর নির্ভর করে: register, sensor, সময়, interrupt. তৃতীয়ত, ভুলের দাম বেশি: বাজারঘরের cold room-এর alarm না বাজলে মাছ-মাংস নষ্ট হয়, আর মাঠে থাকা যন্ত্রের firmware বদলানো কঠিন।

সমাধান হলো কোডকে এমনভাবে ভাগ করা, যাতে বেশিরভাগ test chip ছাড়াই চলে, আর বাকিটুকু ধাপে ধাপে বাস্তবের কাছে যায়। এই পর্বের ছবিটি চার তলার। নিচের তলা যত দ্রুত আর সস্তা, ওপরের তলা তত বাস্তবের কাছে। এই পর্বে register আর ঠিকানা C-এর ধরনে লেখা, যেমন 0x40010800.

ছবি ৬৪.১ — একই C কোড, চারটি test-এর জায়গা

ওপরে দ্রুত আর সস্তা, নিচে ধীর কিন্তু বাস্তবের কাছে; প্রতিটি তলা আলাদা ধরনের ভুল ধরে

একই C কোডের চারটি test-এর জায়গা: host, simulator, HIL আর মাঠ একই C কোড cr_logic.c · price.c · alarm_drv.c ১ · Host PC-তে unit test x86-64 exe, নকল GPIO register ms-এ চলে, দিনে হাজারবার ২ · Instruction-set simulator Clang thumbv7m + virtual BG-M3 সেকেন্ডে, target-এর compiler ৩ · Hardware-in-the-loop আসল board + নকল sensor আর plant মিনিটে, আসল সময় আর pin ৪ · মাঠে, আসল যন্ত্রে আসল cold room, আসল দোকান দিন থেকে মাস, সবচেয়ে দামি দ্রুত, সস্তা → বাস্তবের কাছে বেশিরভাগ test ওপরের দুই তলায়

বাস্তব দলগুলো সাধারণত বেশিরভাগ test রাখে ওপরের দুই তলায়, কারণ সেখানে প্রতিটি কোড বদলের পরে কয়েক সেকেন্ডে ফল পাওয়া যায়। HIL আর মাঠের test কম, কিন্তু বাদ দেওয়া যায় না: আসল সময়ের নিশ্চয়তা, analog-এর noise, তার আর connector-এর গোলমাল শুধু সেখানেই দেখা দেয়। এই পর্বের সব উদাহরণ বাজারঘরের দুটি যন্ত্র নিয়ে, README-এর সংখ্যা মেনে: cold room-এর HIGH alarm 8.00 °C-এর ওপরে, LOW 0.00 °C-এর নিচে, ৩টি পরপর reading-এ নিশ্চিত, 0.50 °C-এর hysteresis; আর smart scale-এর দাম 65.50 টাকা/kg.

২ · Hardware-কে একটি পাতলা দেয়ালের পেছনে রাখা

Reference lab-এর coldroom.c একটি ফাইলে সব করে: I2C-এর register থেকে তাপমাত্রা পড়ে, ৩টি counter দিয়ে alarm-এর নিয়ম চালায়, GPIOA->BSRR-এ লিখে PA6 জ্বালায় আর UART-এ ছাপে। শেখার জন্য এটি সুন্দর, কিন্তু test করা কঠিন। নিয়মটি test করতে হলে পুরো board লাগে, কারণ নিয়মের কোড আর register-এর কোড একই function-এ মেশানো।

রেলস্টেশনের টিকিট কাউন্টারের কথা ভাবুন। যাত্রী জানালার ভেতরে কী ঘটে জানেন না; তিনি শুধু জানেন “ঢাকা, একটি শোভন চেয়ার” বললে টিকিট আসে। ভেতরে কম্পিউটার নাকি খাতা, তাতে যাত্রীর কিছু যায় আসে না। Firmware-এর সেই জানালা হলো HAL (hardware abstraction layer): ছোট কয়েকটি function, যেমন alarm_set(1), যার পেছনে register লুকানো। আমার lab-এ cold room-এর কোড তিন ভাগে ভাঙা হয়েছে:

ফাইলকী করেRegister ছোঁয়?কোথায় test
cr_logic.c৩টি counter আর alarm-এর নিয়ম: cr_step(&c, t16)নাHost-এ, সাধারণ PC-তে
price.cADC count থেকে gram, gram থেকে paisaনাHost-এ
alarm_drv.cPA6 চালু-বন্ধ, শুধু BSRR আর BRR-এ লেখাহ্যাঁ, একটি pointer দিয়েHost-এ নকল register দিয়ে
coldroom2.cSensor পড়া, সময়, ছাপা আর তিনটিকে জোড়াহ্যাঁVirtual board-এ, পরে HIL-এ

শুদ্ধ logic-এর ফাইলটি কত সরল, দেখুন। এখানে #include "bazarghar.h" নেই, কোনো volatile নেই, কোনো ঠিকানা নেই; শুধু একটি struct আর একটি function:

#define HIGH_T16  (8 * 16)    /* 8.00 C, 1/16 C এককে */
#define LOW_T16   0           /* 0.00 C */
#define HYST_T16  8           /* 0.50 C */
#define CONFIRM   3

enum alarm cr_step(cr_t *c, int32_t t16)
{
    c->high = (t16 > HIGH_T16) ? c->high + 1 : 0;
    c->low  = (t16 < LOW_T16)  ? c->low + 1  : 0;
    c->ok = (t16 >= LOW_T16 + HYST_T16 && t16 <= HIGH_T16 - HYST_T16) ? c->ok + 1 : 0;
    if (c->high >= CONFIRM)
        c->state = ALARM_HIGH;
    else if (c->low >= CONFIRM)
        c->state = ALARM_LOW;
    else if (c->state != ALARM_OFF && c->ok >= CONFIRM)
        c->state = ALARM_OFF;
    return c->state;
}

নিয়মটি reference-এর coldroom.c-এর সঙ্গে লাইন ধরে এক (README-এর “বাজারঘর devices”). পার্থক্য শুধু জায়গায়: এখন এটি নিজের ফাইলে, ইনপুট একটি সংখ্যা, আউটপুট একটি enum. যেকোনো C compiler একে compile করতে পারে, তা PC-র হোক বা Cortex-M-এর।

Driver-এর দিকে একটি কৌশল আছে। alarm_init() GPIO port-এর ঠিকানা নিজে বানায় না, বাইরে থেকে একটি pointer পায়। Firmware দেয় আসল GPIOA, test দেয় RAM-এর একটি নকল struct. বাইরে থেকে নির্ভরতা পাওয়ার এই নকশার নাম dependency injection, আর কোড না বদলে আচরণ বদলানোর এমন জায়গাকে বলে seam; দুটির সাধারণ তত্ত্ব সফটওয়্যার টেস্টিং ও QA পর্ব ২৫-এ। C-তে আরও দুটি seam প্রচলিত: link-time (test build-এ আসল .c-এর বদলে নকল .c link করা) আর preprocessor (#ifdef HOST_TEST). আমার driver দ্বিতীয়টিও ব্যবহার করে, প্রতিটি register-এ লেখা খাতায় তোলার জন্য:

#ifdef HOST_TEST                /* seam: test build প্রতিটি লেখা খাতায় তোলে */
void fake_log(const char *reg, uint32_t val);
#define REG_WR(reg, val) do { fake_log(#reg, (val)); (reg) = (val); } while (0)
#else                           /* firmware: শুধু লেখা, কোনো বাড়তি খরচ নেই */
#define REG_WR(reg, val) ((reg) = (val))
#endif

Firmware build-এ macro-টি একটি সাধারণ assignment, তাই বাড়তি একটি নির্দেশও লাগে না। আর gpio_regs_t-এর layout যেন bazarghar.h-এর GPIO_TypeDef-এর সঙ্গে মেলে, তা coldroom2.c-এ দুটি _Static_assert compile-এর সময়েই যাচাই করে (BSRR 0x10, BRR 0x14). Register-এর struct-এর ধারণা পর্ব ৩৬-এ এসেছে।

৩ · Host-এ unit test — red থেকে green

এবার PC-তে test. Host testing-এ firmware-এর শুদ্ধ অংশ সাধারণ কম্পিউটারের compiler দিয়ে একটি সাধারণ program হিসেবে চলে। এখানে host আর target একই কোড পায়, কিন্তু আলাদা compiler-এর আলাদা নির্দেশে। প্রতিটি unit test একটি ছোট function: অবস্থা তৈরি, ইনপুট দেওয়া, ফল মেলানো। Unity বা CppUTest-এর মতো open-source framework এই কাজ সহজ করে; আমার lab-এ দশ লাইনের একটি নিজস্ব test harness (minitest.h), যাতে ভেতরটা চোখে পড়ে:

static enum alarm feed(cr_t *c, int32_t t16, int n)   /* n বার একই reading */
{
    enum alarm a = c->state;
    while (n--) a = cr_step(c, t16);
    return a;
}

static void t_7_50_clears_after_three(void)
{
    cr_t c = { .state = ALARM_HIGH };
    EXPECT_EQ(feed(&c, 120, 2), ALARM_HIGH);     /* 7.50 C দুবার: এখনো HIGH */
    EXPECT_EQ(feed(&c, 120, 1), ALARM_OFF);      /* তৃতীয়বারে বন্ধ */
}

এই test-এর পেছনের কৌশল boundary value analysis: ভুল প্রায়ই সীমায় থাকে, তাই সীমার ঠিক ওপরে, নিচে আর সীমাতেই test (সফটওয়্যার টেস্টিং ও QA পর্ব ০৮)। Cold room-এর সীমা চারটি: 8.00 (ঠিক 8.00 alarm নয়, 8.0625 হ্যাঁ), 0.00, আর বন্ধের ব্যান্ডের দুই প্রান্ত 0.50 আর 7.50 °C. মোট ৭টি test লিখলাম: পাঁচটি সীমার, একটি README-এর পুরো ২০ সেকেন্ডের script-এর, আর একটি দামের হিসাবের (150 g → 983 paisa, 1250 g → 8188, 500 g → 3275, শূন্য আর ঋণাত্মকে 0).

প্রথম খসড়ায় বন্ধের ব্যান্ড লেখা হয়েছিল t16 > 8 && t16 < 120, অর্থাৎ প্রান্ত দুটি বাদ। Clang দিয়ে PC-র জন্য compile করে চালানো হলো:

$ zig cc -std=c11 -O2 -Wall -Wextra -DHOST_TEST -DRED_V1 test_logic.c ../fw/cr_logic.c ../fw/price.c -o test_logic.exe
$ ./test_logic.exe
ok   high_needs_three_readings
ok   exactly_8_00_is_not_high
ok   t_7_75_does_not_clear
  test_logic.c:36: feed(&c, 120, 1) = 1, expected 0
FAIL t_7_50_clears_after_three
  test_logic.c:42: feed(&c, 8, 3) = 2, expected 0
FAIL t_0_50_clears_low
ok   readme_script
ok   price_matches_readme
18 checks, 2 failed
(exit code 1)

সত্যিকারের run (host: x86-64 Windows PC; Clang 22.1.8, ziglang 0.17.1-এর zig cc). দুটি লাল লাইন বলছে কোন লাইনে, কী এসেছে আর কী চাই: 7.50 °C-এ তিনবার পরেও state 1 (ALARM_HIGH), আর 0.50 °C-এ 2 (ALARM_LOW). সবচেয়ে শিক্ষণীয় লাইনটি কিন্তু সবুজ: readme_script পাস করেছে, কারণ README-এর script বন্ধের জন্য 7.00 °C ব্যবহার করে, যা দুই খসড়াতেই ব্যান্ডের ভেতরে। “আসল ঘটনা চালিয়ে দেখেছি, ঠিক আছে” তাই যথেষ্ট নয়; সীমার test আলাদা করে লিখতে হয়।

1hi: t > 128 ? +1 : 02v1 ok: 8 < t < 1203v2 ok: 8 <= t <= 1204st!=OFF && ok>=3: OFF
Test, reading আর ফল
test
t16
ok
state
ফল
  1. শুধু আসল script. প্রথম খসড়ায় README-এর ২০টি reading চালালে alarm 7 s-এ HIGH, 12 s-এ OFF, 17 s-এ LOW, ঠিক board-এর run-এর মতো। Test সবুজ, অথচ কোডে ভুল আছে।
  2. সীমার test. State HIGH থেকে 7.50 °C (t16 = 120) দুবার দেওয়া হলো। লাইন ২-এ 120 < 120 মিথ্যা, তাই ok = 0. দুবার পরে HIGH থাকাই ঠিক, প্রথম যাচাই পাস।
  3. লাল ১। তৃতীয় 7.50-এও ok = 0, তাই লাইন ৪-এর শর্ত মেলে না, state HIGH থাকে। Test ছাপে feed(&c, 120, 1) = 1, expected 0: 1 মানে ALARM_HIGH.
  4. লাল ২। নিচের প্রান্তেও একই ভুল: 0.50 °C (t16 = 8)-এ 8 > 8 মিথ্যা, LOW alarm বন্ধ হয় না। সারাংশ 18 checks, 2 failed, exit code 1.
  5. ন্যূনতম বদল। লাইন ২-এর বদলে লাইন ৩: >= আর <=. এখন 120-এ ok = 1, 2, 3, আর তৃতীয়টিতে লাইন ৪ state-কে OFF করে। README বলে “0.50 … 7.50 °C-এর মধ্যে”, প্রান্তসহ।
  6. সবুজ। আবার চালালে ৭টি test-এর ১৮টি যাচাই পাস, exit code 0. এই test-গুলো এখন থেকে প্রতিটি বদলের পরে চলবে, যাতে ভুলটি আর না ফেরে।

এই ছন্দের নাম red-green-refactor: আগে ব্যর্থ test, তারপর পাস করানোর ন্যূনতম কোড, তারপর গোছানো। আগে test লিখে কোড চালানোর পুরো পদ্ধতি TDD, যার হাতে-কলমে চর্চা সফটওয়্যার টেস্টিং ও QA পর্ব ২৭-এ। একই test ব্রাউজারের Python-এও, দুই খসড়া পাশাপাশি:

# cold room-এর alarm নিয়ম (README) আর তার unit test; t16 = °C × 16
def make_step(inclusive):
    def step(c, t):
        c["hi"] = c["hi"] + 1 if t > 128 else 0          # 8.00 °C-এর ওপরে
        c["lo"] = c["lo"] + 1 if t < 0 else 0            # 0.00 °C-এর নিচে
        band = (8 <= t <= 120) if inclusive else (8 < t < 120)   # 0.50 … 7.50 °C
        c["ok"] = c["ok"] + 1 if band else 0
        if c["hi"] >= 3: c["st"] = "HIGH"
        elif c["lo"] >= 3: c["st"] = "LOW"
        elif c["st"] != "OFF" and c["ok"] >= 3: c["st"] = "OFF"
        return c["st"]
    return step

def feed(step, start, temps):
    c = {"hi": 0, "lo": 0, "ok": 0, "st": start}
    return [step(c, t) for t in temps]

README = [64, 64, 88, 88, 132, 144, 152, 152, 124, 112] + [112] * 4 + [-8] * 6
TESTS = {   # নাম: (শুরুর state, reading-গুলো, শেষে কী চাই)
    "high_needs_three": ("OFF", [129, 129, 129], "HIGH"),
    "exactly_8_00_not_high": ("OFF", [128] * 5, "OFF"),
    "7_75_does_not_clear": ("HIGH", [124] * 5, "HIGH"),
    "7_50_clears": ("HIGH", [120] * 3, "OFF"),
    "0_50_clears_low": ("LOW", [8] * 3, "OFF"),
}
for name, inclusive in (("প্রথম খসড়া (< আর >)", False), ("ঠিক করা (<= আর >=)", True)):
    step, fails = make_step(inclusive), 0
    print(name)
    for test, (start, temps, want) in TESTS.items():
        got = feed(step, start, temps)[-1]
        fails += got != want
        print(f"  {'ok  ' if got == want else 'FAIL'} {test}: got {got}, want {want}")
    seq = feed(step, "OFF", README)
    changes = [(s + 1, a) for s, a in enumerate(seq) if a != (seq[s - 1] if s else "OFF")]
    print(f"  README script changes: {changes}  -> {fails} failed")

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

প্রথম খসড়া (< আর >)
  ok   high_needs_three: got HIGH, want HIGH
  ok   exactly_8_00_not_high: got OFF, want OFF
  ok   7_75_does_not_clear: got HIGH, want HIGH
  FAIL 7_50_clears: got HIGH, want OFF
  FAIL 0_50_clears_low: got LOW, want OFF
  README script changes: [(7, 'HIGH'), (12, 'OFF'), (17, 'LOW')]  -> 2 failed
ঠিক করা (<= আর >=)
  ok   high_needs_three: got HIGH, want HIGH
  ok   exactly_8_00_not_high: got OFF, want OFF
  ok   7_75_does_not_clear: got HIGH, want HIGH
  ok   7_50_clears: got OFF, want OFF
  ok   0_50_clears_low: got OFF, want OFF
  README script changes: [(7, 'HIGH'), (12, 'OFF'), (17, 'LOW')]  -> 0 failed

C-এর host run-এর সঙ্গে হুবহু একই ছবি: দুই খসড়াতেই README-এর ঘটনাক্রম (7, 12, 17 সেকেন্ড) এক, পার্থক্য ধরে শুধু 7.50 আর 0.50 °C-এর test. লক্ষ করুন, 7.75 °C (t16 = 124)-এর test দুই খসড়াতেই পাস, কারণ সেটি ব্যান্ডের বাইরের দিক; hysteresis-এর “ফাঁক” দুই খসড়াতেই ঠিক ছিল, ভুল ছিল শুধু প্রান্তে।

৪ · নকল register — driver-এর test

Logic-এর test সহজ, কারণ তার কোনো hardware নেই। কিন্তু driver-এর কাজই register-এ লেখা। PC-তে 0x40010800 ঠিকানায় লিখলে program ভেঙে পড়বে, কারণ সেখানে কিছু নেই। সমাধান একটি test double: আসল জিনিসের জায়গায় বসানো নকল। ছবির শুটিংয়ে বিপজ্জনক দৃশ্যে নায়কের বদলে যেমন একজন stunt double নামেন, ঠিক তেমন। নকলের কয়েকটি ধরন আছে: stub শুধু ঠিক করা উত্তর ফেরত দেয়, fake একটি সরল কিন্তু কাজ করা নকল, আর mock আগে থেকে জানে কোন ডাক কতবার আসার কথা। এদের তুলনা সফটওয়্যার টেস্টিং ও QA পর্ব ২৪-এ।

Firmware-এ সবচেয়ে সরল fake হলো RAM-এর একটি struct, যার layout আসল register-এর মতো। Driver pointer পেলে বুঝতেই পারে না সে আসল GPIO-তে লিখছে নাকি PC-র memory-তে। সঙ্গে লেখার খাতা থাকলে দেখা যায় কোন register-এ কী ক্রমে লেখা হলো। এটি গুরুত্বপূর্ণ, কারণ alarm চালু করার দুটি উপায় আছে, আর একটি বিপজ্জনক। port->ODR |= ALARM_BIT একটি read-modify-write: পড়া, বদলানো, লেখা। মাঝখানে যদি SysTick-এর ISR PA5-এর সবুজ LED উল্টায়, তাহলে main-এর লেখা সেই বদলকে মুছে দেয়। BSRR-এ একটি মাত্র লেখা সেই ঝুঁকি রাখে না (পর্ব ৩৫ আর পর্ব ৪৩)। নিচের block driver-এর দুটি রূপকে একই test দিয়ে মাপে:

#include <stdio.h>
#include <stdint.h>
#include <string.h>
typedef struct { volatile uint32_t DIR, RES, IDR, ODR, BSRR, BRR; } gpio_t;
#define ALARM_BIT (1u << 6)                       /* PA6 */
static char wlog[8][12]; static int nlog;         /* fake: সব লেখার খাতা */
#define REG_WR(r, v) do { if (nlog < 8) strcpy(wlog[nlog++], #r); (r) = (v); } while (0)

static gpio_t *port;                              /* driver: দুটি রূপ */
static void set_good(int on) { if (on) REG_WR(port->BSRR, ALARM_BIT); else REG_WR(port->BRR, ALARM_BIT); }
static void set_rmw(int on)  { if (on) REG_WR(port->ODR, port->ODR | ALARM_BIT);
                               else    REG_WR(port->ODR, port->ODR & ~ALARM_BIT); }

static int test(const char *name, void (*alarm_set)(int))
{
    gpio_t fake = { .DIR = 0x60, .ODR = 0x20 };   /* PA5 LED জ্বলছে */
    port = &fake; nlog = 0;
    alarm_set(1); alarm_set(0);
    int ok = nlog == 2 && !strcmp(wlog[0], "port->BSRR") && !strcmp(wlog[1], "port->BRR");
    printf("%s %s: writes = %s, %s; ODR = 0x%02X\n", ok ? "ok  " : "FAIL", name,
           wlog[0], wlog[1], (unsigned)fake.ODR);
    return !ok;
}

int main(void)
{
    int failed = test("set_good", set_good) + test("set_rmw", set_rmw);
    printf("%d failed\n", failed);
    return 0;
}

আসল আউটপুট (Wandbox-এর C compiler):

ok   set_good: writes = port->BSRR, port->BRR; ODR = 0x20
FAIL set_rmw: writes = port->ODR, port->ODR; ODR = 0x20
1 failed

দুই রূপেই শেষে ODR = 0x20, অর্থাৎ PA5 জ্বলছে আর PA6 নিভেছে। শুধু শেষ অবস্থা দেখলে দুটিই “ঠিক”। পার্থক্য ধরা পড়েছে লেখার খাতা থেকে: set_rmw ODR-এ দুবার লিখেছে। #r-এর কৌশলে macro register-এর নামটিই লেখা হিসেবে খাতায় তোলে। এটি আচরণ নয়, কীভাবে লেখা হলো তার test; driver-এর মতো নিচু স্তরে সেটিই আসল প্রশ্ন।

Lab-এর আসল ভাগ করা কোডেও (alarm_drv.c আর test_drv.c, host build) একই ফল। প্রথম run সঠিক driver-এর, দ্বিতীয়টি -DRMW_BUG দিয়ে:

$ ./test_drv.exe
ok   init_keeps_other_pins
  write 1: port->BSRR  = 0x40
  write 2: port->BRR   = 0x40
ok   set_and_clear_use_bsrr_brr
5 checks, 0 failed
(exit code 0)

$ ./test_drv.exe          (build: -DRMW_BUG)
ok   init_keeps_other_pins
  write 1: port->ODR   = 0x40
  write 2: port->ODR   = 0x00
  test_drv.c:35: strcmp(log_txt[0], "port->BSRR") = 1, expected 0
  test_drv.c:36: strcmp(log_txt[1], "port->BRR") = 1, expected 0
FAIL set_and_clear_use_bsrr_brr
5 checks, 2 failed
(exit code 1)

সত্যিকারের run (host, Clang 22.1.8). এখানে নকল port-এর ODR শুরুতে 0, তাই খাতায় 0x40 আর 0x00.

test_drv.c: RAM-এর struct fake
ডাক
DIR
ODR
BSRR / BRR
খাতা
ফল
  1. নকল তৈরি। Test RAM-এ একটি gpio_regs_t শূন্য করে, আর DIR = 0x20 রাখে, যেন PA5-এর সবুজ LED আগেই output. আসল board-এ এটি 0x40010800 ঠিকানায়; এখানে PC-র যেকোনো ঠিকানায়।
  2. Init. alarm_init(&fake) DIR পড়ে বিট ৬ যোগ করে লেখে: 0x20 ∣ 0x40 = 0x60. Test যাচাই করে PA5-এর বিট হারায়নি। খাতায় একটি লেখা।
  3. Alarm চালু। খাতা শূন্য করে alarm_set(1): BSRR = 0x40. লক্ষ করুন, ODR এখনো 0x00. আসল GPIO-তে BSRR-এ লিখলে ODR-এর বিট ৬ set হতো; নকল struct শুধু memory, সেই আচরণ তার নেই।
  4. Alarm বন্ধ। alarm_set(0): BRR = 0x40. খাতায় দ্বিতীয় লাইন। কোনো লেখাই পড়া-বদলানো-লেখা নয়, প্রতিটি একটি store.
  5. যাচাই। লেখা ঠিক ২টি, নাম BSRR আর BRR, আর ODR কখনো লেখা হয়নি (0x00). ৫টি যাচাই পাস।
  6. ভুল driver. -DRMW_BUG build-এ খাতায় ODR, ODR (0x40, তারপর 0x00); নামের দুটি যাচাই ব্যর্থ, exit code 1. Interrupt-এর race ঘটানো কঠিন, কিন্তু race-এর কারণটি এভাবে প্রতিবার ধরা যায়।

নকলের সীমা: fake ঠিক ততটাই সত্য, যতটা আপনি তাকে বানিয়েছেন। ধাপ ৩-এ দেখা গেল, struct-এ BSRR লিখলে ODR বদলায় না, যা আসল GPIO-তে বদলায়। কেউ যদি driver-এর test-এ “BSRR লেখার পরে ODR-এর বিট ৬ = 1” আশা করেন, test ভুলভাবে ব্যর্থ হবে; উল্টো দিকে datasheet ভুল বুঝে বানানো fake ভুল driver-কেও পাস করাবে। তাই driver-এর test শেষ কথা নয়; simulator বা আসল board-এ যাচাই লাগবেই। নকলে hardware-এর আচরণ যত বেশি ঢোকাবেন, নকল তত একটি simulator-এর মতো হবে, যা পরের অংশের বিষয়।

৫ · Simulation — instruction-set simulator-এ একই কোড

Host test-এর একটি অন্ধ জায়গা আছে: সেখানে compiler আলাদা, CPU আলাদা। একই C কোড দুই জায়গায় build করে test চালানোকে বলে dual targeting, আর এর দরকার বোঝাতে একটি ছোট পরীক্ষা যথেষ্ট। তিনটি target-এর জন্য Clang-কে দুটি প্রশ্ন করা হলো: plain char কি unsigned, আর int কত বিটের?

Target(char)-1 > 0sizeof(int) * 8মানে
x86-64 Windows (host)032char signed
thumbv7m (Cortex-M3)132char unsigned
AVR016int মাত্র ১৬ বিট

সত্যিকারের run (Clang 22.1.8, -S দিয়ে assembly-তে দুটি global-এর মান পড়া)। অর্থাৎ char c = 200; PC-তে ঋণাত্মক, Cortex-M-এ ধনাত্মক; আর AVR-এ int-এর গুণ 32767 পেরোলেই overflow. PC-তে সবুজ হওয়া test target-এ ভুল হতে পারে। তাই দ্বিতীয় তলা: target-এর নিজের cross-compiler-এ build করে একটি instruction-set simulator-এ চালানো। কোর্সের virtual বাজারঘর board ঠিক তাই: আসল ARMv7-M নির্দেশ চালানো একটি emulator (Unicorn), তার চারপাশে Python-এ লেখা peripheral. এটি কোনো আসল পণ্য নয়, আসল Cortex-M chip-এর আদলে বানানো শেখার board.

Host-এ পরীক্ষিত cr_logic.c আর alarm_drv.c এবার একটুও না বদলে board-এর firmware-এ গেল; coldroom2.c শুধু sensor পড়ে, ছাপে আর দুটিকে জোড়ে। Reference-এর script (coldroom.json) দিয়ে চালানো হলো:

$ python -B bd.py build fw/coldroom2.c fw/cr_logic.c fw/alarm_drv.c -o build/coldroom2.elf
built build/coldroom2.elf
$ python -B bd.py run build/coldroom2.elf --script coldroom.json
[     0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
...
[  7000.0366 ms] UART: t=7 s T=+9.50 C
[  7000.0415 ms] GPIO PA6 ALARM ON
[  7000.0665 ms] UART: ALARM ON: HIGH temperature
...
[ 12000.0446 ms] GPIO PA6 ALARM OFF
[ 12000.0541 ms] UART: ALARM OFF
...
[ 17000.0436 ms] GPIO PA6 ALARM ON
[ 17000.0679 ms] UART: ALARM ON: LOW temperature
...
[ 20000.1121 ms] exit(0) after 160000897 cycles

সত্যিকারের run (বাজারঘর board BG-M3, Clang 22.1.8 / ziglang 0.17.1, Unicorn 2.1.4; bd.py reference-এর board.py-এর একটি ছোট মোড়ক, যা শুধু compiler-এর cache আমার lab-এ রাখে)। Alarm-এর তিনটি ঘটনা README-এর মতোই 7, 12 আর 17 সেকেন্ডে; board-এর নিজের GPIO লাইন দেখায় PA6 সত্যিই উঠেছে-নেমেছে, অর্থাৎ BSRR আর BRR-এর লেখা আসল register-মডেলে কাজ করেছে। মিলিসেকেন্ডের ভগ্নাংশ আর cycle-এর সংখ্যা reference-এর থেকে একটু আলাদা (7000.0387 বনাম 7000.0415), কারণ কোড ভাগ করায় নির্দেশের সংখ্যা বদলেছে; পরের অংশে এর গুরুত্ব।

Simulator-এ test-এর দুটি বড় সুবিধা। প্রথমত, সব কিছু নির্ধারিত: একই input-এ প্রতিবার একই output, তাই ফল একটি ফাইলে রেখে মেলানো যায়। দ্বিতীয়ত, এমন অবস্থা তৈরি করা সহজ, যা আসল জগতে কঠিন: script-এ লিখলেই cold room 9.50 °C, বা ওজন 5100 g. কিন্তু সীমাও স্পষ্ট, আর README নিজেই তা লিখে রেখেছে: এই board-এ ১টি নির্দেশ = ১টি cycle আর exception-এ ঢুকতে ০ cycle (Spec decision 17), interrupt-এর খোঁজ নির্দিষ্ট “boundary”-তে, তাই একটি interrupt 20 000 cycle পর্যন্ত দেরিতে নেওয়া হতে পারে (Spec decision 20), UART-এর পাঠানো তাৎক্ষণিক (Spec decision 24), ADC-র রূপান্তর তাৎক্ষণিক (Spec decision 25), আর I2C শুধু register-স্তরে, বিটের সময় ছাড়া (Spec decision 26). কাজেই এখানে কী ঘটল আর কোন ms-এ ঘটল তা বিশ্বাসযোগ্য, কিন্তু আসল chip-এর সূক্ষ্ম timing নয়।

পুরোনো processor-এর জন্যও একই কৌশল। কোর্সের sim8085.py একটি 8085 simulator (পর্ব ১১-এর program এতেই চলে)। তার --set option দিয়ে একই assembly routine-কে নানা input দিয়ে চালানো যায়, আর Python-এর একটি ছোট script (t8085.py) ফল মেলায়। multiply.asm বারবার যোগ করে গুণ করে, আর তার মাথায় লেখা শর্ত “গুণক শূন্য নয়”:

$ python -B t8085.py
ok   200 x   5 =  1000 (expected  1000)  T-states 189
ok   255 x 255 = 65025 (expected 65025)  T-states 6189
ok     7 x   1 =     7 (expected     7)  T-states 93
ok     0 x   9 =     0 (expected     0)  T-states 285
FAIL 200 x   0 = 51200 (expected     0)  T-states 6213
5 cases, 1 failed

সত্যিকারের run (sim8085.py, প্রতিটি case-এ --set 2050H=…; README-এর lab quirk মেনে হেক্স সংখ্যার শুরুতে 0, যেমন 0C8H). গুণক 0 হলে DCR C 00H থেকে FFH-এ নামে, তাই loop ২৫৬ বার ঘোরে: 256 × 200 = 51200 = C800H, আর T-state = 51 + 256 × 24 − 3 + 16 + 5 = 6213, README-এর সূত্রে। Test শর্তটি কাগজে নয়, সংখ্যায় দেখিয়ে দিল। 8086-এর run8086.py-ও এভাবে ব্যবহার করা যায়, তবে মনে রাখুন Unicorn একটি 386-ধাঁচের CPU, আর আসল 8086-এর সঙ্গে চারটি জানা পার্থক্য আছে (Spec decision 15).

৬ · Regression — expected file-এর সঙ্গে মেলানো

বোর্ড পরীক্ষার খাতা দেখার সময় পরীক্ষক একটি উত্তরপত্রের সঙ্গে মেলান; প্রতিটি খাতার জন্য নতুন করে অঙ্ক কষেন না। Firmware-এর regression test-ও এমন: একবার যাচাই করা পুরো output একটি ফাইলে রাখা হয় (golden file, বা expected file), আর প্রতিটি কোড বদলের পরে নতুন output-কে লাইন ধরে তার সঙ্গে মেলানো হয়। Expected file এখানে test oracle: সঠিক উত্তরের উৎস। Reference lab নিজেই এই পদ্ধতিতে চলে: তার tests/test_board.py প্রতিটি firmware-এর পুরো output-কে firmware/expected/*.txt-এর সঙ্গে হুবহু তুলনা করে। এর সাধারণ রূপ, snapshot আর approval testing, সফটওয়্যার টেস্টিং ও QA পর্ব ৬১-এ।

আমার lab-এর regress.py একই নিয়মে চারটি জিনিস চালায়। একটি পরীক্ষার জন্য reference-এর scale.c-এর একটি কপিতে একটি মাত্র লাইন বদলানো হয়েছে, যা কেউ “সরল করতে” গিয়ে করতে পারেন: দামের rounding-এর + 500 বাদ (scale_trunc.c). তুলনা দুই রকম: exact (প্রতিটি অক্ষর, reference-এর test-এর মতো) আর logical (সময় পূর্ণ ms-এ কাটা, cycle-এর সংখ্যা লুকানো)।

$ python -B regress.py
PASS 8085 multiply.asm            exact    5 lines, 0 differ
PASS board scale                  exact   17 lines, 0 differ
PASS board coldroom               exact   39 lines, 0 differ
FAIL board coldroom2              exact   39 lines, 30 differ
PASS board coldroom2              logical 39 lines, 0 differ
FAIL board scale_trunc            logical 17 lines, 2 differ
    --- expected/scale.txt
    +++ actual
    @@ -6 +6 @@
    -[300 ms] UART: raw=505 gross=150 g tare=0 g net=150 g price=9.83 Tk
    +[300 ms] UART: raw=505 gross=150 g tare=0 g net=150 g price=9.82 Tk
    @@ -12 +12 @@
    -[700 ms] UART: raw=1380 gross=1400 g tare=150 g net=1250 g price=81.88 Tk
    +[700 ms] UART: raw=1380 gross=1400 g tare=150 g net=1250 g price=81.87 Tk
4 of 6 checks passed

সত্যিকারের run (একই board আর compiler). প্রথম তিনটি সারি দেখায়, reference-এর firmware আমার lab-এ নতুন করে build করলেও output অক্ষরে অক্ষরে এক: একই compiler-এর সংস্করণে build পুনরুৎপাদনযোগ্য। চতুর্থ সারি শিক্ষণীয়: coldroom2-এর আচরণ এক, তবু exact তুলনায় ৩৯টির ৩০টি লাইন আলাদা, শুধু ms-এর ভগ্নাংশে। README-এর Spec decision 30 ঠিক এটিই বলে: ভগ্নাংশের অঙ্ক আর cycle-এর সংখ্যা compiler আর কোডের ওপর নির্ভর করে, কিন্তু মান, ক্রম আর কোন ms-এ, তা নয়। তাই logical তুলনায় PASS. শেষ সারিতে logical তুলনা আসল বদলটি ধরেছে: 150 g-এর দাম 982.5 paisa, যা এখন 983-এর বদলে 982.

scale_trunc বনাম expected/scale.txt (logical)
লাইন
expected
actual
ফল
  1. প্রথম পাঁচ লাইন। Reset, খালি platform, “scale ready” আর 0 g-এর লাইন: দামের হিসাব 0 (net ≤ 0 হলে সরাসরি 0), তাই বদলানো লাইনটি এখানে পরীক্ষাই হয়নি। সব মিল।
  2. লাইন ৬, প্রথম অমিল। 150 g: 150 × 6550 = 982 500, ÷ 1000 = 982.5. আগের নিয়মে (982 500 + 500) / 1000 = 983, নতুনে ভাগফল কেটে 982. দোকানদার এক paisa কম পান।
  3. লাইন ৭–১১। বোতাম, TARE 150 g আর net = 0 g-এর লাইন: দাম 0.00 দুই নিয়মেই। মিল।
  4. লাইন ১২, দ্বিতীয় অমিল। 1250 g: 8 187 500 ÷ 1000 = 8187.5; আগে 8188, এখন 8187 paisa, অর্থাৎ 81.88 বনাম 81.87 টাকা।
  5. লাইন ১৩–১৭। OVERLOAD-এর লাইনে দাম নেই, আর 500 g-এ 3 275 000 ÷ 1000 = 3275 ঠিক পূর্ণ সংখ্যা, তাই দুই নিয়মেই 32.75 টাকা। শুধু এই ওজন দিয়ে test করলে বদলটি ধরাই পড়ত না।
  6. রায়। ১৭টির ২টি লাইন আলাদা, script exit code 1 দেয়। CI এই code দেখেই বদলটি আটকায়; কেউ ইচ্ছা করে rounding বদলালে তিনি expected file-ও বদলাবেন, আর review-তে সেই diff সবার চোখে পড়বে।

Logical তুলনার নিয়মটি ব্রাউজারে চালিয়ে দেখুন। প্রথম দুটি তালিকা আসল run থেকে নেওয়া (reference আর coldroom2-এর চারটি লাইন); তৃতীয়টি হাতে বানানো উদাহরণ, যেখানে alarm এক সেকেন্ড দেরিতে বন্ধ হয়:

# regression: expected file বনাম নতুন run — হুবহু, নাকি "যুক্তির" তুলনা?
import difflib, re
expected = """[  7000.0387 ms] GPIO PA6 ALARM ON
[  7000.0634 ms] UART: ALARM ON: HIGH temperature
[ 12000.0418 ms] GPIO PA6 ALARM OFF
[ 20000.1115 ms] exit(0) after 160000892 cycles""".splitlines()
refactored = """[  7000.0415 ms] GPIO PA6 ALARM ON
[  7000.0665 ms] UART: ALARM ON: HIGH temperature
[ 12000.0446 ms] GPIO PA6 ALARM OFF
[ 20000.1121 ms] exit(0) after 160000897 cycles""".splitlines()
broken = """[  7000.0415 ms] GPIO PA6 ALARM ON
[  7000.0665 ms] UART: ALARM ON: HIGH temperature
[ 13000.0446 ms] GPIO PA6 ALARM OFF
[ 20000.1121 ms] exit(0) after 160000897 cycles""".splitlines()

def logical(lines):                      # Spec decision 30: ms-এর ভগ্নাংশ আর cycle বাদ
    out = [re.sub(r"^\[\s*(\d+)\.\d+ ms\]", r"[\1 ms]", ln) for ln in lines]
    return [re.sub(r"after \d+ cycles", "after N cycles", ln) for ln in out]

def compare(name, actual):
    for mode, f in (("exact", lambda x: x), ("logical", logical)):
        diff = [d for d in difflib.unified_diff(f(expected), f(actual), lineterm="", n=0)
                if d[:1] in "+-" and d[:3] not in ("+++", "---")]
        print(f"{name:10} {mode:7}: {'PASS' if not diff else 'FAIL'} ({len(diff) // 2} changed)")
        if diff and mode == "logical":
            print("   " + "\n   ".join(diff))

compare("refactored", refactored)
compare("broken", broken)

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

refactored exact  : FAIL (4 changed)
refactored logical: PASS (0 changed)
broken     exact  : FAIL (4 changed)
broken     logical: FAIL (1 changed)
   -[12000 ms] GPIO PA6 ALARM OFF
   +[13000 ms] GPIO PA6 ALARM OFF

Exact তুলনা দুটিকেই একভাবে ব্যর্থ বলে, তাই কোনটি আসল ভুল, বোঝা যায় না। এমন test যে প্রতিটি নিরীহ বদলেও লাল হয়, দল একসময় তাকে উপেক্ষা করতে শেখে। Logical তুলনা নিরীহ বদলকে পাস করায়, আর আসল বদলটি (alarm 12 s-এর বদলে 13 s-এ বন্ধ) একটি লাইনে দেখায়। নিয়মটি কিন্তু সাবধানে বানাতে হয়: বেশি অংশ মুছলে আসল ভুলও মুছে যায় (অনুশীলন ২ দেখুন)।

৭ · Coverage আর static analysis — দুটি আলাদা আয়না

কতটা test যথেষ্ট? একটি মাপ হলো code coverage: test চলার সময় কোডের কত অংশ অন্তত একবার চলেছে। লাইন ধরে মাপলে statement coverage, প্রতিটি if-এর দুই দিক ধরে মাপলে branch coverage; বিস্তারিত সংজ্ঞা সফটওয়্যার টেস্টিং ও QA পর্ব ১৩-এ। Firmware-এ gcov বা Clang-এর coverage tool host build-এ সহজে চলে; chip-এ চালাতে বাড়তি মেমরি আর data বের করার পথ লাগে। ধারণাটি বোঝাতে নিচের block Python-এর sys.settrace দিয়ে নিজেই মাপে, কোন লাইন চলল:

# line coverage হাতে মাপা: sys.settrace প্রতিটি চলা লাইন জানায়
import sys
def cr_step(c, t):                    # নিচের লাইনগুলো def থেকে 1, 2, 3 … গোনা
    if t > 128:                       # 1
        c["hi"] += 1                  # 2
    else: c["hi"] = 0                 # 3
    if t < 0:                         # 4
        c["lo"] += 1                  # 5
    else: c["lo"] = 0                 # 6
    if 8 <= t <= 120:                 # 7  (0.50 … 7.50 °C)
        c["ok"] += 1                  # 8
    else: c["ok"] = 0                 # 9
    if c["hi"] >= 3:                  # 10
        c["st"] = "HIGH"              # 11
    elif c["lo"] >= 3:                # 12
        c["st"] = "LOW"               # 13
    elif c["st"] != "OFF" and c["ok"] >= 3:   # 14
        c["st"] = "OFF"               # 15
    return c["st"]                    # 16

F = cr_step.__code__.co_firstlineno
BODY = {ln - F for _, _, ln in cr_step.__code__.co_lines() if ln and ln > F}
def coverage(temps):
    seen = set()
    def tracer(frame, event, arg):
        if frame.f_code is cr_step.__code__ and event == "line":
            seen.add(frame.f_lineno - F)
        return tracer
    c = {"hi": 0, "lo": 0, "ok": 0, "st": "OFF"}
    sys.settrace(tracer)
    for t in temps: cr_step(c, t)
    sys.settrace(None)
    return f"{len(seen & BODY)}/{len(BODY)} lines, missed {sorted(BODY - seen)}"
print("normal only [4.00 C x5]:", coverage([64] * 5))
print("README script (20)     :", coverage([64, 64, 88, 88, 132, 144, 152, 152, 124, 112] + [112] * 4 + [-8] * 6))

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

normal only [4.00 C x5]: 10/16 lines, missed [2, 5, 9, 11, 13, 15]
README script (20)     : 16/16 lines, missed []

শুধু স্বাভাবিক 4.00 °C দিলে ১৬টির ৬টি লাইন কখনো চলে না, তার তিনটি alarm চালু বা বন্ধের লাইন (১১, ১৩, ১৫)। এমন test-suite যন্ত্রের আসল কাজটিই পরীক্ষা করে না, আর coverage সেটি চোখে আঙুল দিয়ে দেখায়। README-এর script দিলে ১৬টির ১৬টি, অর্থাৎ ১০০%. কিন্তু অংশ ৩-এ দেখেছি, ঠিক এই script ব্যান্ডের প্রান্তের ভুল ধরতে পারেনি। লাইন ৭-এ <=-এর বদলে < থাকলেও coverage ১০০%-ই থাকত। Coverage বলে কোথায় test নেই; কোথায় test যথেষ্ট, তা বলে না।

এ কারণে নিরাপত্তা-সংকট সফটওয়্যারে আরও কড়া মাপ লাগে। MC/DC-তে প্রতিটি শর্তকে (যেমন লাইন ১৪-এর st != "OFF" আর ok >= 3) আলাদাভাবে ফল বদলাতে দেখাতে হয়। বিমানের software-এর মান DO-178C সবচেয়ে কঠিন স্তরের (Level A) software-এর জন্য MC/DC চায় বলে ব্যাপকভাবে উল্লেখিত; গাড়ির ISO 26262-ও সর্বোচ্চ ঝুঁকির স্তরে এটি জোরালোভাবে সুপারিশ করে বলে জানা যায়। এসব মানের পরিচয় পর্ব ৬৩ (নির্ভরযোগ্যতা আর safety)-এ। Test-এর মান মাপার আরেকটি উপায়, mutation testing, ঠিক অংশ ৬-এর মতো ছোট ইচ্ছাকৃত বদল করে দেখে test সেগুলো ধরে কি না (সফটওয়্যার টেস্টিং ও QA পর্ব ৫৯)।

দ্বিতীয় আয়না কোড না চালিয়েই দেখে। Static analysis source পড়ে সম্ভাব্য ভুল খোঁজে। এর প্রথম ধাপ compiler-এর নিজের warning. নিচের ফাইলে তিনটি ছোট function, যাতে চারটি ভুল লুকানো (warn_demo.c, firmware-এর ধাঁচে):

int32_t avg4(const uint16_t *s, int n)
{
    uint32_t sum = 0;
    for (uint32_t i = 0; i < n; i++)        /* ভুল ১: unsigned বনাম signed */
        sum += s[i];
    return (sum + 2) / 4;
}

const char *alarm_text(enum alarm a)
{
    const char *t;
    switch (a) {                              /* ভুল ২: ALARM_OFF নেই, t অনির্দিষ্ট */
    case ALARM_HIGH: t = "HIGH"; break;
    case ALARM_LOW:  t = "LOW";  break;
    }
    return t;
}

int is_cold(uint32_t t_centi, enum alarm a)
{
    if (a = ALARM_LOW)                        /* ভুল ৩: == নয়, = */
        return 1;
    return t_centi < 0;                       /* ভুল ৪: unsigned কখনো < 0 নয় */
}

Cortex-M3-এর জন্য -Wall -Wextra দিয়ে compile:

$ clang --target=thumbv7m-none-eabi -mcpu=cortex-m3 -std=c11 -O2 -Wall -Wextra -c warn_demo.c
warn_demo.c:7:28: warning: comparison of integers of different signs: 'uint32_t' (aka 'unsigned int') and 'int' [-Wsign-compare]
warn_demo.c:15:13: warning: enumeration value 'ALARM_OFF' not handled in switch [-Wswitch]
warn_demo.c:24:11: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
3 warnings generated.

$ clang --target=thumbv7m-none-eabi -mcpu=cortex-m3 --analyze warn_demo.c
warn_demo.c:19:5: warning: Undefined or garbage value returned to caller [core.uninitialized.UndefReturn]
warn_demo.c:15:5: note: 'Default' branch taken. Execution continues on line 19
warn_demo.c:24:9: warning: Although the value stored to 'a' is used in the enclosing expression, the value is never actually read from 'a' [deadcode.DeadStores]
2 warnings generated.

$ clang --target=thumbv7m-none-eabi ... -Wtautological-unsigned-zero-compare -c warn_demo.c
warn_demo.c:26:20: warning: result of comparison of unsigned expression < 0 is always false [-Wtautological-unsigned-zero-compare]

সত্যিকারের run (Clang 22.1.8; প্রতিটি warning-এর নিচের কোডের-ছবি আর note-এর কিছু লাইন জায়গা বাঁচাতে বাদ)। তিনটি ফল লক্ষ করুন। Compiler-এর warning ভুল ১, ২ আর ৩-এর জায়গা দেখিয়েছে। --analyze দিয়ে চালানো static analyzer (Clang Static Analyzer, একই Clang-এর ভেতরে) প্রোগ্রামের পথ ধরে চিন্তা করে বলেছে আসল পরিণাম: ALARM_OFF এলে “default” পথে t অনির্দিষ্ট অবস্থায় ফেরত যায়। আর ভুল ৪, t_centi < 0, প্রথম দুই run-এর কেউ ধরেনি; ধরা পড়েছে শুধু আলাদা একটি flag চালু করলে। শিক্ষা: কোন flag চালু, তা জেনে বেছে নিতে হয়, আর কোনো একটি tool সব ধরে না। Reference lab-এর board build নিজেই -Wall -Wextra -Werror ব্যবহার করে, অর্থাৎ একটি warning থাকলেও build থামে। এর পরের ধাপ clang-tidy বা cppcheck-এর মতো আলাদা analyzer আর MISRA C-এর মতো নিয়মের সংকলন, যা পর্ব ৬৩-এর বিষয়; এই পর্বের lab-এ সেগুলো চালানো হয়নি। Review আর static testing-এর সাধারণ দিক সফটওয়্যার টেস্টিং ও QA পর্ব ০৬-এ।

৮ · Hardware-in-the-loop আর আসল যন্ত্রে test

গাড়ি চালানো শেখার আগে অনেকে simulator-এ বসেন: আসল steering, আসল brake প্যাডেল, কিন্তু রাস্তা পর্দায়। Hardware-in-the-loop (HIL) test ঠিক উল্টো দিক থেকে একই কাজ: আসল controller board, আসল firmware, আসল pin, কিন্তু চারপাশের জগৎ নকল। একটি test কম্পিউটার board-এর input-এ sensor-এর মতো সংকেত দেয় আর output-এর সাড়া মাপে। নকল জগৎটি একটি plant model: যে জিনিস নিয়ন্ত্রণ হচ্ছে (cold room-এর বাতাস, motor, গাড়ি) তার গাণিতিক নকল, যা real time-এ চলে।

বাজারঘরের cold room-এর একটি HIL নকশা কেমন হতে পারে, তার একটি রূপরেখা (এই কোর্সে কোনো আসল hardware নেই, তাই এটি চালানো হয়নি): আসল board-এর I2C pin-এ একটি দ্বিতীয় microcontroller বসানো, যা 0x48 ঠিকানার sensor সেজে test কম্পিউটারের বলা তাপমাত্রা ফেরত দেয়। Test কম্পিউটার একটি সরল ঘরের মডেল চালায়: compressor বন্ধ থাকলে প্রতি মিনিটে তাপমাত্রা কিছুটা বাড়ে, চালু থাকলে কমে। সে PA6-এর pin পড়ে alarm-এর সময় মাপে, আর board-এর UART লাইন ধরে রাখে। একই README-এর ঘটনা এবার আসল timing-এ চলে, আর ফল আবার একটি expected file-এর সঙ্গে মেলে। এমন test কী ধরে যা simulator ধরে না, নিচের তালিকায়:

ভুলের ধরনHost unit testSimulator (BG-M3)HIL / আসল board
নিয়ম আর হিসাব (hysteresis, দাম)হ্যাঁ, সবচেয়ে দ্রুতহ্যাঁহ্যাঁ, কিন্তু ধীরে
Target compiler-এর পার্থক্য (char, int-এর মাপ)নাহ্যাঁহ্যাঁ
Register-এর ক্রম আর ঠিকানাFake যতটা সঠিকBoard-মডেল যতটা সঠিকহ্যাঁ
আসল timing, interrupt latency, jitterনানা (Spec decision 17, 20)হ্যাঁ
Bus-এর বিট-স্তর, clock stretching, noiseনানা (Spec decision 26)হ্যাঁ
Analog, তাপ, ভোল্টেজের ওঠানামানানাঅংশত; বাকিটা মাঠে

HIL-এর দাম আছে: বাড়তি hardware, rig বানানো আর রক্ষণাবেক্ষণ, আর প্রতিটি run-এ মিনিট। তাই গাড়ি, বিমান আর শিল্প-যন্ত্রের মতো ক্ষেত্রে HIL ব্যাপক, যেখানে মাঠে ভুলের দাম অনেক বেশি; ছোট যন্ত্রে প্রায়ই একটি সরল “test jig” থাকে, যা কয়েকটি pin নাড়িয়ে মূল আচরণ দেখে। Production-এ প্রতিটি তৈরি board-এর একটি ছোট end-of-line test-ও হয়, যা firmware নয়, সোল্ডারিং আর component-এর ভুল খোঁজে।

সব তলাকে জুড়ে রাখে continuous integration (CI): প্রতিটি কোড বদলে একটি server নিজে host test, cross-compile-এর -Werror build, simulator-এর regression চালায়, আর রাতে বা release-এর আগে HIL. Exit code-ই সেখানে ভাষা: regress.py-এর 1 মানে “এখানে থামুন”। Pipeline-এর নকশা সফটওয়্যার টেস্টিং ও QA পর্ব ৬৪-এ। আর debugger, semihosting ও trace দিয়ে আসল board-এ ভুল খোঁজা পর্ব ৩৮-এর বিষয়; test ভুলের অস্তিত্ব জানায়, debugging তার কারণ খোঁজে।

আরও গভীরে: Embedded C-তে TDD-কে জনপ্রিয় করেছে James W. Grenning-এর বই “Test-Driven Development for Embedded C” (Pragmatic Bookshelf, ২০১১), যেখানে dual targeting, link-time seam আর নকল register-এর মতো কৌশল বিস্তারিত; বইটির উদাহরণ Unity আর CppUTest framework-এ। QEMU (Fabrice Bellard, প্রথম প্রকাশ ২০০৩) বহু MCU-র জন্য পূর্ণ board-এর emulation দেয়, আর এই কোর্সের board যে Unicorn-এর ওপর বানানো, সেটি QEMU-র CPU অংশ থেকেই তৈরি। কিছু simulator আরও এক ধাপ যায়: cycle-নির্ভুল মডেল আর “virtual platform”, যেখানে chip তৈরির আগেই firmware চালানো যায়।

পরীক্ষা ও ইন্টারভিউতে: (১) “Hardware ছাড়া firmware কীভাবে test করবেন?” → logic আলাদা করে host-এ unit test, register-এর জন্য fake বা HAL-এর পেছনে test double, তারপর simulator, শেষে HIL. (২) “Host test পাস করলেও target-এ ভুল কেন?” → আলাদা compiler: plain char-এর sign, int-এর মাপ (AVR-এ ১৬ বিট), endianness, alignment, আর আসল timing. (৩) “Simulator-এর সীমা?” → মডেলে যা নেই তা দেখায় না: সূক্ষ্ম timing, analog, bus-এর noise. (৪) “১০০% coverage মানে কি নির্ভুল?” → না; শুধু প্রতিটি লাইন চলেছে, সীমার মান আর ফল যাচাই হয়েছে কি না বলে না। (৫) “HIL কী?” → আসল controller + নকল পরিবেশ (plant model) real time-এ, সংকেত দিয়ে সাড়া মাপা।

৯ · AI-এর যুগে firmware-এর test লেখানো আর যাচাই

AI assistant-কে “এই function-এর unit test লিখুন” বললে কয়েক সেকেন্ডে একগাদা test আসে, আর প্রায় সবই সবুজ। সমস্যা ঠিক সেখানেই: AI প্রায়ই কোড পড়ে সেই কোডের আচরণকেই “প্রত্যাশিত” ধরে test লেখে, ফলে ভুল কোডের জন্য ভুল test তৈরি হয়। Expected মান আসতে হবে spec থেকে, এখানে README থেকে, কোড থেকে নয়। সবচেয়ে চেনা ভুল আর ধরার উপায়:

AI প্রায়ই যা করেকীভাবে ধরবেন
Expected মান কোড চালিয়ে বসায় (যেমন 7.50 °C-এ HIGH “ঠিক” ধরে)প্রতিটি expected মান README বা datasheet থেকে নিজে লিখুন; সীমার মান আলাদা করে
শুধু “সুখের পথ”: স্বাভাবিক তাপমাত্রা, সাধারণ ওজনCoverage মাপুন; alarm চালু-বন্ধ, overload, ঋণাত্মক, শূন্য আর সীমার test আছে কি না দেখুন
নির্দিষ্ট chip-এর বানানো register নাম বা ঠিকানা দিয়ে fakeFake-এর layout আসল header বা reference manual-এর সঙ্গে _Static_assert দিয়ে মেলান
Driver-এ ODR |=, ISR-এর ভ্যারিয়েবল volatile নয়লেখার খাতার test, আর target-এর -S আউটপুট পড়া
Simulator বা host-এর সময়কে আসল chip-এর সময় বলে দাবিBoard-এর README-এর সীমা পড়ুন; timing শুধু datasheet আর আসল hardware-এর মাপে
Test-এ আসল Wi-Fi password বা tokenসবসময় নকল মান; secret কখনো test বা expected file-এ নয়

AI-কে spec, সীমা আর যাচাইয়ের শর্ত শুরুতেই দিন:

আমি একটি Cortex-M3 firmware-এর cold-room alarm নিয়ম host-এ (PC-তে) C11-এ unit test করছি। Function: enum alarm cr_step(cr_t *c, int32_t t16); t16 = তাপমাত্রা × 16. নিয়ম (spec): 8.00 °C-এর ওপরে পরপর ৩টি reading হলে HIGH, 0.00 °C-এর নিচে পরপর ৩টি হলে LOW; alarm বন্ধ হয় পরপর ৩টি reading 0.50 থেকে 7.50 °C-এর মধ্যে (দুই প্রান্তসহ) এলে। ১. Expected মান কোড থেকে নয়, শুধু এই spec থেকে নাও। ২. Boundary value analysis দিয়ে প্রতিটি সীমার (8.00, 0.00, 0.50, 7.50) ঠিক ওপরে, নিচে আর সীমাতেই test লেখো, t16-এ। ৩. Register-এ লেখা একটি driver-এর জন্য RAM-এর fake struct আর লেখার খাতা দিয়ে test দেখাও; ODR-এ read-modify-write হলে test ব্যর্থ হবে। ৪. কোন ভুল host test ধরতে পারবে না (timing, char-এর sign, int-এর মাপ), আলাদা করে তালিকা দাও। ৫. কোনো chip-নির্দিষ্ট register বা framework-এর API নিয়ে নিশ্চিত না হলে বলো "নিশ্চিত নই, datasheet বা অফিসিয়াল ডকুমেন্টেশন দেখুন"।

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

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

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

প্র ০১Ariane 5-এর প্রথম উড্ডয়ন (১৯৯৬) ব্যর্থ হয়েছিল এমন একটি software-এর কারণে, যা আগের rocket-এ বছরের পর বছর ঠিকঠাক চলেছিল। Testing-এর দিক থেকে এই ঘটনার শিক্ষা কী?

৪ জুন ১৯৯৬-এ Ariane 5-এর প্রথম উড্ডয়ন (Flight 501) উৎক্ষেপণের প্রায় ৪০ সেকেন্ড পরে ধ্বংস হয়। তদন্ত বোর্ডের প্রকাশিত প্রতিবেদন অনুযায়ী মূল কারণ inertial reference system (SRI)-এর software-এ একটি সংখ্যার রূপান্তর: ৬৪ বিটের floating-point একটি মান ১৬ বিটের signed integer-এ নেওয়ার সময় সীমা পেরিয়ে যায়, আর সেই ব্যতিক্রম সামলানোর ব্যবস্থা ছিল না। কোডটি Ariane 4 থেকে নেওয়া, যেখানে সেই মান কখনো এত বড় হতো না; Ariane 5-এর পথ আলাদা, তাই হলো। ঘটনার নিরাপত্তা আর নির্ভরযোগ্যতার দিক পর্ব ৬৩ (নির্ভরযোগ্যতা আর safety)-এর বিষয়; এখানে শুধু test-এর দিক।

প্রতিবেদনের সারাংশ বলে, উন্নয়নের সময়ের ব্যাপক পর্যালোচনা আর test SRI আর পুরো flight control system-এর যথেষ্ট বিশ্লেষণ ও test অন্তর্ভুক্ত করেনি, যা সম্ভাব্য ব্যর্থতা ধরতে পারত। বিভিন্ন সূত্রে উল্লেখ আছে, system-স্তরের simulation-এ আসল SRI-র বদলে তার simulated output ব্যবহার করা হয়েছিল। এই পর্বের ভাষায়: একটি অংশ নকল দিয়ে বদলানো হয়েছিল, আর নকলটি আসল অংশের সেই আচরণ (Ariane 5-এর পথে overflow) দেখাতে পারত না। অংশ ৪-এর সতর্কবাণী এখানে বড় পরিসরে: fake ঠিক ততটাই সত্য, যতটা তাকে বানানো হয়েছে।

দ্বিতীয় শিক্ষা পুনর্ব্যবহারের। পুরোনো কোড “পরীক্ষিত” মানে পুরোনো পরিবেশে পরীক্ষিত। নতুন পরিবেশে, নতুন সীমার মানে, সেই test আবার চালাতে হয়। প্রতিবেদনের সুপারিশের মধ্যে ছিল যতটা সম্ভব আসল যন্ত্র দিয়ে যাচাই আর আসল পথের data দিয়ে simulation. বাজারঘরের ছোট উদাহরণে একই গঠন: README-এর script দুই খসড়াতেই পাস করেছিল, কারণ তা সীমার কাছে যায়নি; সীমার test আলাদা করে লিখতে হয়েছে।

মূল উপলব্ধি: পুনর্ব্যবহৃত কোডের test-ও নতুন পরিবেশের সীমা দিয়ে নতুন করে চালাতে হয়, আর যে অংশ নকল দিয়ে বদলানো হয়েছে, সেখানে test-এর অন্ধ জায়গা থাকে।

প্র ০২Host-এ সব test সবুজ, অথচ একই কোড microcontroller-এ ভুল করে। এমন কেন হয়, আর dual targeting কীভাবে সাহায্য করে?

Host test-এর শক্তি আর দুর্বলতা একই জায়গায়: সেখানে কোড অন্য compiler, অন্য CPU আর অন্য C “implementation”-এ চলে। C মান অনেক বিষয় implementation-এর ওপর ছেড়ে দিয়েছে। এই পর্বের ছোট run দেখিয়েছে, Clang x86-64-এ plain char-কে signed ধরে, Cortex-M3-এ (thumbv7m) unsigned; আর AVR-এ int মাত্র ১৬ বিট। ধরুন কেউ sensor-এর একটি byte char-এ রেখে ঋণাত্মক কি না দেখেন: PC-তে −0.50 °C ঠিকঠাক ঋণাত্মক, ARM-এ একই byte 255-এর কাছে বড় ধনাত্মক। Smart scale-এর দাম যদি AVR-এ int-এ গুণ হতো, 1250 × 6550 ১৬ বিটে উপচে যেত; host-এ ৩২ বিটে সব সবুজ।

আরও পার্থক্য আছে: endianness (x86 আর বেশিরভাগ Cortex-M দুটিই little-endian, কিন্তু কিছু DSP বা network-এর data নয়), alignment (Cortex-M0-তে অসংলগ্ন word পড়া fault দেয়, PC-তে চুপচাপ চলে), stack-এর আকার (PC-তে কয়েক MB, MCU-তে কয়েক KB, পর্ব ৩৯), আর অবশ্যই timing আর interrupt. Optimization-ও আলাদা: volatile ভুলে যাওয়া কোড host-এর -O0-এ চলে, target-এর -O2-এ থেমে যায় (পর্ব ৩৪)।

Dual targeting মানে একই test দুই জায়গায় চালানো: দ্রুত চক্রের জন্য host-এ, আর নিয়মিত target-এর compiler-এ build করে simulator বা আসল board-এ। James Grenning-এর embedded TDD-র বইয়ে (২০১১) এটি মূল কৌশল হিসেবে আছে। এই কোর্সের lab-এ ঠিক তাই হয়েছে: cr_logic.c প্রথমে PC-তে ৭টি test, তারপর thumbv7m-এর Clang-এ compile করে virtual board-এ README-এর পুরো script, ফল logical তুলনায় reference-এর সমান। বাড়তি সাবধানতা হিসেবে কোডে fixed-width টাইপ (int32_t, uint8_t) ব্যবহার করা, আর গুরুত্বপূর্ণ ধারণা _Static_assert দিয়ে compile-এর সময় যাচাই।

মূল উপলব্ধি: Host test নিয়ম যাচাই করে, compiler আর CPU-র পার্থক্য নয়; তাই একই test target-এর compiler-এও চালাতে হয়, আর টাইপের মাপ নিজে নির্দিষ্ট করতে হয়।

প্র ০৩Simulator, emulator আর আসল hardware-এর replica: মহাকাশযানের মতো দূরের যন্ত্রের firmware-এর ভুল খুঁজতে মাটিতে কী রাখা হয়, আর কেন?

Simulator একটি মডেল চালায়: যা মডেলে আছে, তাই দেখায়। Emulator আসল নির্দেশ চালায়, তাই compiler-এর ভুল বা target-নির্দিষ্ট আচরণও ধরা পড়ে; তবু তার peripheral আর timing-এর মডেল সীমিত। এই কোর্সের board দুইয়ের মিশ্রণ: CPU-র নির্দেশ Unicorn emulator চালায়, যা QEMU-র CPU অংশ থেকে তৈরি; peripheral আর exception-এর নিয়ম Python-এর মডেল। README সৎভাবে লিখে রেখেছে কী নেই: আসল cycle-এর হিসাব (Spec decision 17), UART-এর baud-এর সময় (24), I2C-এর বিট-স্তর (26).

দূরের যন্ত্রে এর চেয়েও বেশি লাগে। ১৯৯৭ সালে Mars Pathfinder মঙ্গলে নামার কিছুদিন পরে বারবার reset হতে থাকে। বহুল প্রচারিত বর্ণনা অনুযায়ী, JPL-এর প্রকৌশলীরা পৃথিবীতে রাখা একটি প্রায় অভিন্ন test system-এ একই ঘটনা ঘটাতে পেরেছিলেন, trace দেখে কারণ পান priority inversion (পর্ব ৫৭-এর বিষয়), আর RTOS-এর একটি setting বদলে সমাধান মহাকাশযানে পাঠান। এখানে replica-ই সবকিছু: মঙ্গলে debugger লাগানো যায় না, আর simulator-এ সেই নির্দিষ্ট সময়ের মিল ধরা পড়েনি।

এই কারণেই গুরুত্বপূর্ণ প্রকল্পে প্রায়ই তিন স্তর থাকে: ডেস্কে দ্রুত simulator বা emulator, আলাদা ঘরে আসল board-সহ HIL rig, আর মাঠের যন্ত্রের একটি বা একাধিক অভিন্ন কপি, যেখানে মাঠের ঘটনা আবার ঘটানো যায়। বাজারঘরের মতো ছোট ব্যবসায় হয়তো একটি অতিরিক্ত cold-room board আর একটি বাড়তি sensor-ই যথেষ্ট, যা দোকানের যন্ত্রের firmware চালায় আর নতুন সংস্করণ আগে সেখানে চলে।

সবশেষে খরচের হিসাব: simulator-এ একটি test প্রায় বিনামূল্যে হাজারবার চলে, replica-তে একটি run-এ মানুষের সময় লাগে, মাঠে একটি ভুলের দাম যন্ত্রের ভেতরের মাল আর গ্রাহকের ভরসা।

মূল উপলব্ধি: প্রতিটি নকল বাস্তবের একটি অংশ ধরে; যে ভুল মডেলের বাইরে, তা খুঁজতে আসল hardware বা তার অভিন্ন কপি লাগে।

প্র ০৪বিমান আর গাড়ির software-এর মান কেন শুধু line coverage-এ সন্তুষ্ট নয়? MC/DC কী বাড়তি দেয়, আর তারও সীমা কোথায়?

অংশ ৭-এর block দেখিয়েছে, README-এর script cold room-এর নিয়মের ১৬টি লাইনের সবগুলো চালায়, অথচ ব্যান্ডের প্রান্তের ভুল ধরে না। Line coverage শুধু বলে প্রতিটি লাইন অন্তত একবার চলেছে। Branch coverage আরও একটু চায়: প্রতিটি if-এর সত্য আর মিথ্যা দুই দিক। কিন্তু একটি শর্তে কয়েকটি অংশ থাকলে (লাইন ১৪-এর st != "OFF" and ok >= 3) দুই দিক দেখা হলেও জানা যায় না প্রতিটি অংশ আলাদাভাবে গুরুত্বপূর্ণ কি না।

MC/DC (modified condition/decision coverage) চায়, প্রতিটি অংশের জন্য এমন দুটি test, যেখানে শুধু সেই অংশ বদলায় আর পুরো সিদ্ধান্তের ফলও বদলায়। লাইন ১৪-এর জন্য: (st HIGH, ok 3) → OFF; (st OFF, ok 3) → বদল নেই, অর্থাৎ প্রথম অংশ কাজ করছে; (st HIGH, ok 2) → বদল নেই, অর্থাৎ দ্বিতীয় অংশও। সাধারণত n টি অংশের জন্য n + 1টি test. বিমানের software-এর মান DO-178C (২০১১-১২ সালে প্রকাশিত, আগের DO-178B ১৯৯২) সবচেয়ে কঠিন স্তরের software-এর জন্য MC/DC চায় বলে ব্যাপকভাবে উল্লেখিত; গাড়ির ISO 26262-এ সর্বোচ্চ ঝুঁকির স্তরে MC/DC জোরালোভাবে সুপারিশকৃত বলে জানা যায়। সঠিক ধারা মানের মূল নথিতে দেখতে হয়, যা বিনামূল্যে নয়।

তবু MC/DC-রও সীমা আছে। এটি দেখে শর্তের প্রতিটি অংশ ফল বদলাতে পারে কি না; সীমার মান ঠিক কি না (7.50 °C-এ <=), বা spec নিজেই ভুল কি না, তা দেখে না। 7.50-এর ভুল ধরতে লাগে boundary value analysis, যা coverage নয়, test নকশার কৌশল। আর coverage-এর লক্ষ্য একটি সংখ্যা হয়ে গেলে লোকে assertion ছাড়া “লাইন চালানো” test লেখে, যা coverage বাড়ায়, কিছু যাচাই করে না। Mutation testing সেই ফাঁক ধরে, কারণ ইচ্ছাকৃত ভুল ঢুকিয়ে দেখে test লাল হয় কি না।

মূল উপলব্ধি: Coverage বলে কোথায় test নেই; সীমার মান আর সঠিক expected ফল আসে test নকশা আর spec থেকে, আর mutation বলে test আসলে কিছু ধরে কি না।

প্র ০৫১৯৭০-এর দশকের lint থেকে আজকের Clang Static Analyzer: কোড না চালিয়ে ভুল খোঁজার tool কীভাবে বদলেছে, আর firmware দলে এদের জায়গা কোথায়?

১৯৭০-এর দশকের শেষে Bell Labs-এ Stephen C. Johnson lint নামে একটি program লেখেন বলে বহুল উল্লেখিত, যা C কোডের সন্দেহজনক জায়গা দেখাত: টাইপের অমিল, ব্যবহার না হওয়া ভ্যারিয়েবল, function-এর ভুল argument. তখনকার compiler ছোট মেমরিতে চলত বলে এসব পরীক্ষা আলাদা program-এ রাখা হয়েছিল। পরে compiler নিজেই অনেক warning দিতে শিখল, যার কিছু এই পর্বের run-এ দেখা গেছে: signed-unsigned তুলনা, switch-এ বাদ পড়া enum, if-এর ভেতরে =.

পরের ধাপ পথ-সংবেদী বিশ্লেষণ। Clang Static Analyzer প্রোগ্রামের সম্ভাব্য পথগুলো প্রতীকীভাবে অনুসরণ করে, তাই বলতে পারে “switch-এর default পথে t অনির্দিষ্ট অবস্থায় ফেরত যায়”; শুধু লাইন দেখা warning তা পারে না। দাম দুটি: বিশ্লেষণ ধীর, আর কখনো ভুল সতর্কতা আসে। আবার কিছুই ধরে না এমন জায়গাও থাকে: এই পর্বের t_centi < 0, যা ধরা পড়েছে শুধু আলাদা একটি flag চালু করলে।

নিরাপত্তা-সংকট firmware-এ এর সঙ্গে যোগ হয় কোডের নিয়মের সংকলন, যেমন MISRA C (প্রথম সংস্করণ ১৯৯৮), যার অনেক নিয়ম tool দিয়ে যাচাই করা যায়; নিয়মগুলো পর্ব ৬৩-এর বিষয়। ব্যবহারিক নীতি সাধারণত এমন: build-এ -Wall -Wextra -Werror (reference lab-এর board build যেমন), প্রতিটি merge-এর আগে একটি analyzer, আর ব্যতিক্রম হলে কারণসহ লিখিত অনুমতি।

Static analysis আর test একে অপরের বদলি নয়। Test নির্দিষ্ট input-এ ফল যাচাই করে কিন্তু না-চলা পথ দেখে না; analyzer সব পথ দেখার চেষ্টা করে কিন্তু spec জানে না, তাই 7.50 °C-এর ভুল কখনো ধরবে না।

মূল উপলব্ধি: Compiler-এর warning, path-সংবেদী analyzer আর test তিনটি আলাদা আয়না; একসাথে ব্যবহার করলে এবং কোন flag চালু তা জেনে বাছলে ফাঁক কমে।

অনুশীলন

প্রথমে নিজে লিখুন বা হিসাব করুন, তারপর উত্তর খুলুন। প্রতিটি উত্তর lab-এ চালিয়ে বা হিসাব-script দিয়ে যাচাই করা।

  1. নকশা ও বাস্তবায়ন — smart scale-এর হিসাবের unit test: বাজারঘরের smart scale-এর দুটি শুদ্ধ function আছে: raw_to_grams(raw) (400 counts = 0 g, 1800 counts = 2000 g, অর্ধেক হলে শূন্য থেকে দূরে round) আর price_paisa(net_g) (6550 paisa/kg, (net × 6550 + 500) / 1000, net ≤ 0 হলে 0). Boundary value analysis দিয়ে অন্তত ৮টি test-এর তালিকা (input আর expected) বানান, আর একটি EXPECT_EQ-ধাঁচের C test function লিখুন।
    static void scale_boundaries(void)
    {
        EXPECT_EQ(raw_to_grams(400), 0);       /* শূন্যের calibration বিন্দু */
        EXPECT_EQ(raw_to_grams(399), -1);      /* ঠিক নিচে */
        EXPECT_EQ(raw_to_grams(401), 1);       /* ঠিক ওপরে */
        EXPECT_EQ(raw_to_grams(1800), 2000);   /* span-এর বিন্দু */
        EXPECT_EQ(raw_to_grams(0), -571);      /* ADC-র সর্বনিম্ন */
        EXPECT_EQ(raw_to_grams(4095), 5279);   /* ADC-র সর্বোচ্চ (12 বিট) */
        EXPECT_EQ(price_paisa(0), 0);          /* net ≤ 0 */
        EXPECT_EQ(price_paisa(-20), 0);
        EXPECT_EQ(price_paisa(1), 7);          /* 6.55 → 7 */
        EXPECT_EQ(price_paisa(150), 983);      /* ঠিক অর্ধেক: 982.5 → 983 */
        EXPECT_EQ(price_paisa(5000), 32750);   /* ক্ষমতার সীমা */
    }

    প্রতিটি expected মান হাতে হিসাব করা আর lab-এর host build-এ চালিয়ে মেলানো। কয়েকটি ব্যাখ্যা: raw 401 → (1 × 2000 + 700) / 1400 = 1.93 → 1 g; raw 0 → −(800 000 + 700) / 1400 → −571 g (ঋণাত্মকে শূন্য থেকে দূরে round); raw 4095 → (3695 × 2000 + 700) / 1400 = 5279 g, যা 5000 g-এর ক্ষমতার ওপরে, তাই firmware-এ OVERLOAD দেখাতে হবে (overload-এর সিদ্ধান্তটি main-এ, আলাদা test-এ)। 150 g বিশেষ, কারণ ঠিক অর্ধেক paisa-র rounding যাচাই করে; অংশ ৬-এর + 500 বাদের ভুল ঠিক এই test-ই ধরত, 500 g ধরত না। পূর্ণ ক্ষমতায় 5000 × 6550 = 32 750 000, int32_t-এর মধ্যে নিরাপদ।

  2. ভুল খুঁজুন — সবসময় সবুজ regression: একজন সহকর্মী board-এর output-এ ms-এর ভগ্নাংশের বদলে বিরক্ত হয়ে তুলনার আগে প্রতিটি লাইনে re.sub(r"\d+\.\d+", "X", line) চালালেন। এরপর নিচের দুটি লাইন তুলনা করা হলো: expected [ 300.0978 ms] UART: raw=505 … price=9.83 Tk, actual [ 300.0991 ms] UART: raw=505 … price=9.82 Tk. Test কী বলবে, ভুলটা কোথায়, আর ঠিক নিয়ম কী?

    Test PASS বলবে, যা ভুল। Regex \d+\.\d+ শুধু সময় নয়, দশমিকসহ যেকোনো সংখ্যা মুছে দেয়, তাই দুই লাইনই হয়ে যায় [ X ms] UART: raw=505 … price=X Tk; দামের পার্থক্য (9.83 বনাম 9.82) মুছে গেছে। Lab-এ Python দিয়ে চালিয়ে দেখা: দুটি normalize করা লাইন সমান (True). ঠিক নিয়ম হলো শুধু লাইনের শুরুর সময়ের অংশকে ধরা, যেমন ^\[\s*(\d+)\.\d+ ms\] → [\1 ms], আর cycle-এর সংখ্যার জন্য আলাদা নির্দিষ্ট pattern (after \d+ cycles). একটি ভালো অভ্যাস: normalize-এর নিয়ম বদলালে একটি জানা-ভুল output (অংশ ৬-এর scale_trunc) দিয়ে নিশ্চিত হওয়া যে test এখনো লাল হয়।

  3. আগে বলুন, তারপর মেলান — শূন্য গুণকের 8085 গুণ: এই 8085 routine 2050H আর 2051H-এর দুটি byte গুণ করে 2052H–2053H-এ রাখে: LDA 2050H / MOV E,A / MVI D,00H / LDA 2051H / MOV C,A / LXI H,0000H / LOOP: DAD D / DCR C / JNZ LOOP / SHLD 2052H / HLT. গুণক 5 হলে মোট 189 T-state. [2050H] = C8H (200) আর [2051H] = 00H হলে [2052H] আর [2053H]-এ কী থাকবে, মোট কত T-state, আর এই test-এর ব্যর্থতা থেকে routine-এ কী যোগ করা উচিত?

    DAD D আগে চলে, তারপর DCR C: C = 00H থেকে কমে FFH, Z = 0, তাই loop চলতেই থাকে, মোট ২৫৬ বার। HL = 256 × 200 = 51200 = C800H, তাই [2052H] = 00H, [2053H] = C8H. T-state: loop-এর বাইরের অংশ 51, প্রতিটি ঘোরা 24 (DAD 10 + DCR 4 + JNZ নেওয়া 10), শেষ ঘোরায় JNZ না নেওয়ায় 3 কম, তারপর SHLD 16 আর HLT 5: 51 + 256 × 24 − 3 + 16 + 5 = 6213. কোর্সের simulator-এ চালানো t8085.py হুবহু তাই দিয়েছে (FAIL 200 x 0 = 51200 … T-states 6213). সমাধান: loop-এ ঢোকার আগে গুণক শূন্য কি না দেখা, যেমন MOV A,C / ORA A / JZ STORE (HL তখনো 0000H), আর এই case-টি test-এর তালিকায় স্থায়ীভাবে রাখা।

  4. হিসাব — কোন লাইন test-এ চলল: অংশ ৭-এর ১৬ লাইনের cr_step (লাইন ১–১৬, def থেকে গোনা) state OFF থেকে শুরু করে এই ৬টি reading পায়: 9.00, 9.00, 9.00, 7.00, 7.00, 7.00 °C (t16 = 144 ×3, তারপর 112 ×3). কোন লাইনগুলো কখনো চলবে না? Line coverage কত? আর এই test-suite-এ কী যোগ করলে ১০০% হবে?

    চলবে না লাইন ৫ (c["lo"] += 1) আর ১৩ (c["st"] = "LOW"), কারণ কোনো reading 0.00 °C-এর নিচে নয়। বাকিগুলো চলে: 144-এ লাইন ২ আর ৯ (ব্যান্ডের বাইরে), তৃতীয় 144-এ লাইন ১১ (HIGH); 112-এ লাইন ৩ আর ৮; প্রথম দুই 144-এ লাইন ১২ আর ১৪ পরীক্ষা হয়; তৃতীয় 112-এ লাইন ১৫ (OFF). Coverage = ১৪/১৬ = ৮৭.৫%. অংশ ৭-এর block-এর coverage() দিয়ে চালিয়ে মেলানো: 14/16 lines, missed [5, 13]. ১০০% করতে পরপর তিনটি শূন্যের নিচের reading যোগ করুন, যেমন −0.50 °C (t16 = −8) তিনবার। তবে মনে রাখুন, ১০০% হলেও 0.50 আর 7.50-এর সীমার test আলাদা করে লাগবে।

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

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

ক্রমএকটি firmware-এর নিয়ম বদলানোর পরে test-এর ধাপগুলো দ্রুত থেকে বাস্তবের দিকে সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. Host কম্পিউটারে নতুন নিয়মের একটি ব্যর্থ unit test লেখা
  2. ন্যূনতম কোড বদলে host-এর সব unit test সবুজ করা
  3. Target-এর compiler-এ warning-কে error ধরে build করা
  4. Simulator-এ firmware চালিয়ে expected file-এর সঙ্গে regression মেলানো
  5. আসল board-এ hardware-in-the-loop test চালানো
  6. অল্প কয়েকটি যন্ত্রে মাঠে চালিয়ে দেখা

একটি cold-room alarm বন্ধ হওয়ার কথা পরপর ৩টি reading 0.50 থেকে 7.50 °C-এর মধ্যে (দুই প্রান্তসহ) এলে। কোডে লেখা আছে t > 0.50 && t < 7.50. কোন test এই ভুল ধরবে?

  • HIGH alarm-এর পরে 7.00 °C তিনবার দেওয়া
  • HIGH alarm-এর পরে 7.75 °C তিনবার দেওয়া
  • HIGH alarm-এর পরে 7.50 °C তিনবার দেওয়া
  • OFF অবস্থা থেকে 9.00 °C তিনবার দেওয়া

একটি STM32-ধাঁচের GPIO-তে main code একটি alarm pin চালু করে, আর SysTick-এর ISR একই port-এর আরেকটি LED উল্টায়। Alarm চালুর জন্য ODR |= (1u << 6)-এর চেয়ে BSRR = (1u << 6) কেন ভালো?

  • BSRR-এ লেখা ODR-এর চেয়ে অনেক দ্রুত বলে
  • BSRR-এর একটি লেখা অন্য pin-এ হাত দেয় না, তাই ISR-এর বদল হারায় না
  • ODR-এ লিখলে pin চালু হয় না
  • BSRR-এর জন্য volatile লাগে না বলে

একটি firmware-এর কোড ভাগ করে নতুন করে সাজানোর (refactoring) পরে simulator-এর output-কে পুরোনো expected file-এর সঙ্গে অক্ষরে অক্ষরে মেলালে ৩৯টির ৩০টি লাইন আলাদা, শুধু সময়ের [7000.0387 ms]-এর মতো ms-এর ভগ্নাংশে; সব মান আর ঘটনার ক্রম এক। সবচেয়ে যুক্তিসঙ্গত পদক্ষেপ কী?

  • Refactoring বাতিল করা, কারণ আচরণ বদলেছে
  • কিছু না দেখেই নতুন output দিয়ে expected file বদলে দেওয়া
  • এই firmware-এর regression test বন্ধ করা
  • তুলনায় শুধু ms-এর ভগ্নাংশ আর cycle-এর সংখ্যা নির্দিষ্ট নিয়মে বাদ দেওয়া

একটি function-এর unit test-suite চালিয়ে line coverage ১০০% পাওয়া গেল। এ থেকে নিশ্চিতভাবে কী বলা যায়?

  • প্রতিটি লাইন অন্তত একবার চলেছে, এর বেশি কিছু নয়
  • Function-এ আর কোনো ভুল নেই
  • প্রতিটি if-এর সত্য আর মিথ্যা দুই দিকই পরীক্ষিত
  • MC/DC-ও ১০০%

Hardware-in-the-loop (HIL) test-এর সবচেয়ে সঠিক বর্ণনা কোনটি?

  • PC-তে firmware-এর শুদ্ধ logic compile করে test
  • আসল controller board, আর তার চারপাশের জগৎ কম্পিউটারের নকল মডেল
  • ARM-এর নির্দেশ software-এ চালানো একটি virtual board
  • আসল যন্ত্র আসল দোকানে বসিয়ে কয়েক মাস দেখা

একটি sensor-এর byte char b-এ রেখে if (b < 0) দিয়ে ঋণাত্মক তাপমাত্রা দেখা হয়। x86-64 PC-তে Clang দিয়ে চালানো test পাস করে, কিন্তু একই কোড Cortex-M3 (arm-none-eabi)-এর জন্য compile করলে শর্তটি কখনো সত্য হয় না। কারণ কী?

  • Cortex-M3-এ int ১৬ বিট
  • Cortex-M3 big-endian
  • ARM-এ plain char unsigned, x86-এ signed
  • -O2-এর optimization ভুল করে শর্তটি মুছে দেয়

C-তে const char *t; switch (a) { case 1: t = "HIGH"; break; case 2: t = "LOW"; break; } return t; লেখা আছে, যেখানে a একটি enum-এর মান (0, 1 বা 2). কোন tool প্রোগ্রামের পথ ধরে বলবে যে একটি পথে অনির্দিষ্ট মান ফেরত যায়?

  • Line coverage-এর রিপোর্ট
  • নকল register-এর লেখার খাতা
  • Expected file-এর সঙ্গে regression
  • Path-সংবেদী static analyzer, যেমন clang --analyze

শব্দকোষ

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

মনে রাখুন

  1. ভাগ করুন: নিয়ম আর হিসাব register ছাড়া শুদ্ধ C-তে, register শুধু পাতলা driver-এ; driver pointer বা seam দিয়ে আসল বা নকল port পায়।
  2. Host-এ unit test: দ্রুত, বারবার; সীমার test আলাদা করে (7.50 আর 0.50 °C-এ < বনাম <=), red থেকে green.
  3. নকল register: RAM-এর struct আর লেখার খাতা দেখায় কী, কোথায়, কী ক্রমে লেখা হলো; কিন্তু নকল hardware-এর আচরণ জানে না।
  4. Simulator আর regression: target-এর compiler-এ build করে একই কোড চালানো; expected file-এর সঙ্গে logical তুলনা (Spec decision 30), নিরীহ বদলে পাস, আসল বদলে লাল।
  5. সীমা জানুন: coverage ১০০% ≠ নির্ভুল; warning আর analyzer আলাদা ভুল ধরে; আসল timing আর analog শুধু HIL আর মাঠে।

পরের পর্বে: পর্ব ৬৫ (Sensor interfacing — তাপমাত্রা, ওজন, আলো আর গতির sensor). বাজারঘরের যন্ত্রের আসল sensor: load cell আর তার amplifier, তাপমাত্রার sensor, আর অন্য সাধারণ sensor কীভাবে microcontroller-এর সঙ্গে জোড়া হয়।

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

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