এমবেডেড C — হার্ডওয়্যারের সাথে সরাসরি কথা

১ · আপনার চারপাশে লুকানো কম্পিউটার

সকালে উঠে রাইস কুকারে চাল দিলেন। কুকার নিজেই বুঝল কখন পানি শুকিয়েছে, তারপর “cook” থেকে “warm” মোডে চলে গেল। রাস্তায় বেরিয়ে দেখলেন ট্রাফিক সিগন্যাল সময় মেপে রং বদলাচ্ছে। দোকানে bKash বা কার্ডে বিল দিলেন একটি POS মেশিনে। মেট্রো রেলের গেটে কার্ড ছোঁয়ালেন। প্রতিটি জায়গায় একটি করে ছোট কম্পিউটার কাজ করছে, অথচ কোথাও কোনো কীবোর্ড, মাউস বা Windows চোখে পড়েনি।

এই লুকানো কম্পিউটারগুলোকে বলে embedded system — বড় যন্ত্রের ভেতরে বসানো, একটিমাত্র কাজের জন্য তৈরি কম্পিউটার। আর এদের মস্তিষ্ক সাধারণত একটি মাইক্রোকন্ট্রোলার: একটি চিপ, যার ভেতরেই CPU, মেমরি আর বাইরের জগতের সাথে যোগাযোগের অংশ একসাথে। এদের ভেতরের প্রোগ্রামকে বলে firmware, আর পৃথিবীর বেশিরভাগ firmware আজও লেখা হয় C-তে।

যাঁরা শুরু করতে চান, তাঁদের জন্য কয়েকটি জনপ্রিয় বোর্ড ও চিপ। ঢাকার এলিফ্যান্ট রোড বা অনলাইন দোকানে এগুলোর কিট এখন সহজেই পাওয়া যায়, আর বিশ্ববিদ্যালয়ের প্রজেক্ট থেকে শুরু করে দেশি স্টার্টআপের IoT যন্ত্র পর্যন্ত — সবখানে এগুলোর ব্যবহার বাড়ছে। সংখ্যাগুলো খেয়াল করুন:

একটি সাধারণ ল্যাপটপে ৮ GB RAM থাকে। Arduino Uno-র চিপে আছে ২ KB — প্রায় ৪০ লাখ ভাগের এক ভাগ! এই পর্বে আপনার পরিচিত printf, malloc বা float যে এখানে বিলাসিতা, তার কারণ এই সংখ্যাটিই। আরেকটি বিভ্রান্তি দূর করে নিই: সাধারণ Raspberry Pi বোর্ড (যেমন Pi 4) আসলে Linux চালানো একটি পূর্ণ কম্পিউটার; আর Raspberry Pi Pico একটি মাইক্রোকন্ট্রোলার বোর্ড, যেখানে OS নেই। নাম কাছাকাছি, জগৎ আলাদা।

২ · মাইক্রোকন্ট্রোলারের ভেতরে কী আছে

আপনার ল্যাপটপে CPU একটি চিপ, RAM আলাদা কার্ড, SSD আলাদা, Wi-Fi আলাদা। মাইক্রোকন্ট্রোলারে সবকিছু একটি ছোট চিপের ভেতরে গুটিয়ে রাখা। একটি টিনের ছোট দোকানের কথা ভাবুন — দোকানদারই ক্যাশিয়ার, তিনিই মাল তোলেন, তিনিই হিসাব লেখেন। জায়গা কম, কিন্তু সব হাতের কাছে।

• CPU core: নির্দেশ চালায়। গতি মাপা হয় clock speed দিয়ে — Arduino Uno-তে ১৬ MHz, অর্থাৎ সেকেন্ডে ১ কোটি ৬০ লাখ টিক। ল্যাপটপের কয়েক GHz-এর তুলনায় ধীর, কিন্তু একটি বাতি বা মোটর চালাতে যথেষ্টর চেয়ে বেশি।
• Flash: প্রোগ্রামের কোড আর স্থির ডেটা। বিদ্যুৎ গেলেও মোছে না — তাই লোডশেডিংয়ের পর কুকার আবার নিজের প্রোগ্রাম নিয়েই জেগে ওঠে।
• SRAM: ভ্যারিয়েবল আর stack. দ্রুত, কিন্তু খুবই কম, আর বিদ্যুৎ গেলে সব মুছে যায়।
• Peripheral: CPU-র পাশে বসানো ছোট ছোট বিশেষজ্ঞ যন্ত্র। নিচের টেবিলে প্রধানগুলো।

OS নেই — তাহলে কে সামলায়?

আপনার ল্যাপটপে প্রোগ্রাম চালু হলে OS তাকে মেমরি দেয়, ফাইল খোলে, স্ক্রিনে লেখা দেখায়, আর ভুল ঠিকানায় হাত দিলে Segmentation fault দিয়ে থামিয়ে দেয়। এই শেষ কাজটি করে CPU-র MMU নামের অংশ। ছোট মাইক্রোকন্ট্রোলারে MMU নেই, OS-ও সাধারণত নেই। একে বলে bare metal প্রোগ্রামিং — আপনার কোড আর খালি হার্ডওয়্যার, মাঝখানে কেউ নেই। ভুল ঠিকানায় লিখলে কেউ থামাবে না; হয়তো চুপচাপ অন্য একটি পিন বদলে যাবে।

কাজ যখন বেশি জটিল হয় — একসাথে Wi-Fi সামলানো, সেন্সর পড়া, ডিসপ্লে আপডেট — তখন ব্যবহার হয় একটি RTOS. সবচেয়ে পরিচিত উদাহরণ FreeRTOS, যা ESP32-এর অফিশিয়াল সফটওয়্যার কাঠামোর ভেতরেই চলে। RTOS কয়েকটি task-কে অগ্রাধিকার অনুযায়ী ভাগ করে চালায়, অনেকটা পর্ব ৪৯-এর thread-এর মতো, কিন্তু অনেক ছোট পরিসরে।

৩ · রেজিস্টার — যে ঠিকানায় লিখলে বাতি জ্বলে

পর্ব ৪৫-এ memory-mapped I/O-র কথা প্রথম শুনেছেন। এবার পুরো ছবিটা দেখি। মাইক্রোকন্ট্রোলারের প্রতিটি peripheral-এর কিছু নিয়ন্ত্রণ-ঘর আছে, যাকে বলে register. প্রতিটি রেজিস্টার একটি নির্দিষ্ট মেমরি-ঠিকানায় বসানো, আর তার প্রতিটি বিট হার্ডওয়্যারের একটি তারের সাথে যুক্ত। একটি GPIO পোর্টের output data register (ODR)-এর বিট ৫-এ 1 লিখলে পিন ৫-এ ভোল্টেজ আসে, আর সেই পিনে জোড়া LED জ্বলে ওঠে। আপনার C কোড সত্যিই বিদ্যুৎ নিয়ন্ত্রণ করছে।

C-তে একটি নির্দিষ্ট ঠিকানাকে রেজিস্টার হিসেবে ব্যবহার করার প্রচলিত লেখা এরকম। নিচের ঠিকানাগুলো উদাহরণ — STM32F4 সিরিজের reference manual-এ GPIOA পোর্টের ঠিকানা; অন্য চিপে এগুলো সম্পূর্ণ আলাদা হবে:

/* উদাহরণ: STM32F4-এর GPIOA (ঠিকানা চিপের reference manual থেকে) */
#define GPIOA_ODR   (*(volatile uint32_t *)0x40020014u)
#define GPIOA_BSRR  (*(volatile uint32_t *)0x40020018u)

GPIOA_ODR |= (1u << 5);      /* পিন PA5 চালু — LED জ্বলো */
GPIOA_ODR &= ~(1u << 5);     /* পিন PA5 বন্ধ — LED নেভো */

লাইনটি ভেতর থেকে পড়ুন। 0x40020014u একটি সাধারণ সংখ্যা। (volatile uint32_t *) compiler-কে জানায়: “এটি একটি ৩২ বিটের রেজিস্টারের ঠিকানা, আর এর মান যেকোনো সময় বাইরে থেকে বদলাতে পারে।” সামনের * সেই ঠিকানার ভেতরের মানটি দেয়। ফলে GPIOA_ODR লিখলে সেটি একটি সাধারণ ভ্যারিয়েবলের মতো ব্যবহার করা যায়। টাইপ হিসেবে int নয়, stdint.h-এর uint32_t — কারণ রেজিস্টার ঠিক ৩২ বিটের, আর embedded কোডে “কত বিট” কখনো অনুমানের ওপর ছাড়া হয় না।

কেন volatile? পর্ব ৪৫-এর polling লুপের কথা মনে করুন: volatile ছাড়া compiler একবার পড়ে ধরে নিত মান আর বদলাবে না, অথবা পরপর দুটি লেখার প্রথমটি “অকারণ” ভেবে মুছে দিত। রেজিস্টারে প্রতিটি পড়া ও লেখা একটি সত্যিকার ঘটনা, তাই একটিও বাদ দেওয়া চলবে না।

এবার সবচেয়ে গুরুত্বপূর্ণ প্রশ্ন: GPIOA_ODR |= (1u << 5) লাইনটি আসলে কয়টি ধাপে চলে? নিচের ডায়াগ্রামে দেখুন। ধরা যাক পিন ০ (একটি বাজার) আর পিন ৩ (একটি ফ্যানের রিলে) আগে থেকেই চালু:

bit       7 6 5 4 3 2 1 0
ODR       0 0 0 0 1 0 0 1   = 0x09

bit       7 6 5 4 3 2 1 0
mask      0 0 1 0 0 0 0 0   = 0x20 = 32

ldr  r1, [r0]      ; r1 = ODR = 0x09

r1        0 0 0 0 1 0 0 1
mask      0 0 1 0 0 0 0 0
OR        ---------------
r1        0 0 1 0 1 0 0 1   = 0x29

str  r1, [r0]      ; ODR = 0x29 → পিন ৫-এ ভোল্টেজ

GPIOA_BSRR = (1u << 5);         /* শুধু পিন ৫ চালু   */
GPIOA_BSRR = (1u << (5 + 16));  /* শুধু পিন ৫ বন্ধ   */
/* 0 লেখা বিটগুলো কিছুই বদলায় না — পড়ার দরকারই নেই */

একটি করে ঠিকানা নয় — পুরো রেজিস্টার-ব্লক একটি struct

একটি GPIO পোর্টে ডজনখানেক রেজিস্টার পাশাপাশি থাকে, প্রতিটি ৪ বাইট দূরে। প্রত্যেকটির জন্য আলাদা #define না লিখে পেশাদার কোডে পুরো ব্লকটিকে একটি struct হিসেবে ঘোষণা করা হয় (পর্ব ২২), তারপর ব্লকের শুরুর ঠিকানাকে সেই struct-এর পয়েন্টার বানানো হয়:

typedef struct {            /* উদাহরণ: STM32F4 GPIO-র রেজিস্টার ক্রম */
    volatile uint32_t MODER;    /* +0x00  পিনের মোড        */
    volatile uint32_t OTYPER;   /* +0x04                   */
    volatile uint32_t OSPEEDR;  /* +0x08                   */
    volatile uint32_t PUPDR;    /* +0x0C                   */
    volatile uint32_t IDR;      /* +0x10  ইনপুট পড়া        */
    volatile uint32_t ODR;      /* +0x14  আউটপুট লেখা       */
    volatile uint32_t BSRR;     /* +0x18  atomic set/reset */
} GPIO_TypeDef;

#define GPIOA ((GPIO_TypeDef *)0x40020000u)

GPIOA->BSRR = (1u << 5);    /* LED জ্বলো */

এখানে struct-এর প্রতিটি সদস্য ঠিক ৪ বাইট, তাই কোনো padding ঢোকে না, আর সদস্যের ক্রম হুবহু হার্ডওয়্যারের ক্রম মেনে চলে। এই ধাঁচটিকে সব কোম্পানির জন্য একই রকম করেছে ARM-এর CMSIS — STM32, NXP বা Nordic, যার Cortex-M চিপই হোক, header ফাইলে প্রায় একই চেহারার struct পাবেন। ARM Cortex-M3/M4-এর কিছু চিপে আরেকটি কৌশলও আছে, bit-banding: একটি বিশেষ ঠিকানা-অঞ্চলে প্রতিটি বিটের নিজস্ব ঠিকানা, সেখানে লিখলে একটি বিট একবারেই বদলায়।

৪ · Super-loop — যে লুপ কখনো শেষ হয় না

আপনার ল্যাপটপের প্রোগ্রাম কাজ শেষে return 0 দিয়ে OS-এর কাছে ফেরত যায়। কিন্তু মাইক্রোকন্ট্রোলারে ফেরার কোনো জায়গা নেই — main শেষ হয়ে গেলে CPU কী করবে, কেউ জানে না। তাই embedded প্রোগ্রামের সবচেয়ে প্রচলিত কাঠামো হলো super-loop:

int main(void) {
    hardware_init();          /* clock, পিনের মোড, টাইমার — একবারই */
    while (1) {               /* চিরকাল */
        read_inputs();        /* বাটন, সেন্সর */
        update_logic();       /* সিদ্ধান্ত */
        write_outputs();      /* LED, মোটর, ডিসপ্লে */
    }
}

চায়ের দোকানের মামার কথা ভাবুন: চুলা দেখেন, কেটলিতে পানি দেন, কাপ ধোন, টাকা নেন — আবার চুলা দেখেন। দোকান বন্ধ না হওয়া পর্যন্ত এই চক্র থামে না। Super-loop ঠিক তাই, আর বিদ্যুৎ বন্ধ না হওয়া পর্যন্ত চলে।

Embedded জগতের “Hello, World” হলো LED জ্বালানো-নেভানো (blink). সবচেয়ে সরল রূপটি এমন:

while (1) {
    GPIOA->ODR ^= (1u << 5);   /* toggle */
    delay_ms(500);              /* অর্ধেক সেকেন্ড অপেক্ষা */
}

এখানে delay_ms সাধারণত একটি busy-wait: একটি ফাঁকা লুপ, যা শুধু গুনে গুনে সময় নষ্ট করে। সহজ, কিন্তু দুটি সমস্যা। এক, অপেক্ষার পুরো ৫০০ ms CPU আর কিছুই করতে পারে না — বাটন চাপলেও শুনবে না। দুই, গোনা লুপের সময় নির্ভর করে clock-এর গতি আর compiler-এর optimization-এর ওপর (volatile ছাড়া optimizer পুরো ফাঁকা লুপটাই মুছে দিতে পারে)। পেশাদার সমাধান হলো হার্ডওয়্যার টাইমার: টাইমার নিজে নিজে গোনে, প্রতি ১ ms-এ একটি “টিক” দেয়, আর মূল লুপ শুধু দেখে, “৫০০ টিক পেরিয়েছে কি?” অপেক্ষার ফাঁকে CPU বাকি কাজ সেরে নেয়।

আমাদের অনলাইন compiler একটি সাধারণ Linux সার্ভারে চলে, সেখানে কোনো LED নেই। তাই নিচের কোডে হার্ডওয়্যারের অনুকরণ করা হয়েছে: RAM-এর একটি volatile struct আসল রেজিস্টার-ব্লকের জায়গা নিয়েছে। লুপটি ৬টি টিক চলে (আসল চিপে চলত চিরকাল), প্রতিবার LED উল্টে দেয়, আর রেজিস্টারের নিচের ৮টি বিট ছাপে:

#include <stdio.h>
#include <stdint.h>
typedef struct { volatile uint32_t IDR, ODR; } GPIO_Type;  /* register block */
static GPIO_Type fake_port;              /* RAM stands in for the hardware */
#define GPIOA  (&fake_port)              /* real chip: a fixed address */
#define LED    (1u << 5)                 /* LED on pin 5 */

static void show(int t, uint32_t v) {
    printf("tick %d  ODR=0x%02X  ", t, (unsigned)v);
    for (int b = 7; b >= 0; b--) putchar(((v >> b) & 1u) ? '1' : '0');
    printf("  LED %s\n", (v & LED) ? "ON" : "off");
}
int main(void) {
    GPIOA->ODR = 0x01;                   /* pin 0 is already on */
    for (int tick = 1; tick <= 6; tick++) {   /* super-loop, 6 rounds */
        GPIOA->ODR ^= LED;               /* toggle = read-modify-write */
        show(tick, GPIOA->ODR);
    }
    GPIOA->ODR = (GPIOA->ODR | (1u << 3)) & ~0x01u;  /* set 3, clear 0 */
    show(7, GPIOA->ODR);
    return 0;
}

৫ · Polling না interrupt — কে আগে খবর পায়

ধরুন আপনার super-loop-এ একটি ডিসপ্লে আপডেট আছে, যাতে প্রতিবার ৪০ ms লাগে। এর মধ্যে কেউ বাটন চাপল। প্রোগ্রাম কীভাবে জানবে? দুটি উপায় আছে।

একটি দ্রুত টোকা — বাটন মাত্র ১৮ ms চাপা থাকল। দুই পদ্ধতিতে কী ঘটে, পাশাপাশি দেখুন:

ISR লেখার চারটি নিয়ম

volatile uint8_t button_flag = 0;     /* ISR আর main দুজনেই দেখে */

void EXTI0_IRQHandler(void) {         /* উদাহরণ: STM32-র ISR-এর নাম */
    EXTI->PR = 1u;                    /* interrupt-এর flag মুছে দেওয়া */
    button_flag = 1;                  /* শুধু খবর রেখে বেরিয়ে যাওয়া   */
}

int main(void) {
    hardware_init();
    for (;;) {
        if (button_flag) { button_flag = 0; handle_button(); }
        update_display();
    }
}

1. ছোট রাখুন। ISR চলার সময় মূল লুপ পুরো থেমে থাকে, আর একই বা কম অগ্রাধিকারের অন্য interrupt-ও অপেক্ষা করে। ভারী কাজ (ডিসপ্লে, হিসাব, লগ) মূল লুপে পাঠান।
2. ভাগ করা ভ্যারিয়েবল volatile. নইলে মূল লুপের if (button_flag) compiler একবার পড়ে চিরকালের জন্য ধরে রাখতে পারে — পর্ব ৪৫-এর সেই আটকে যাওয়া লুপ।
3. ISR-এ printf, malloc বা দীর্ঘ delay নয়। এগুলো ধীর, অনেক সময় নিজেরাই interrupt-এর ওপর নির্ভর করে, আর reentrant নয় — পর্ব ৪৫-এর signal handler-এর নিয়মের মতোই।
4. Hardware flag মুছে দিন। অনেক চিপে ISR-এর ভেতরে interrupt-এর “pending” বিট নিজে মুছতে হয়; না মুছলে বেরোনোর সাথে সাথে ISR আবার চলে, প্রোগ্রাম চিরকাল সেখানেই ঘুরতে থাকে।

Critical section — যখন main আর ISR একই ডেটা ছোঁয়

একটি টাইমার ISR প্রতি ১ ms-এ একটি ৩২ বিটের counter বাড়ায়: ticks++. মূল লুপ সেটি পড়ে। ৩২ বিটের ARM-এ একটি পড়া একবারেই হয়। কিন্তু ৮ বিটের AVR-এ ৩২ বিটের মান পড়তে লাগে চারটি আলাদা নির্দেশ! ধরুন counter 0x000000FF. মূল লুপ নিচের byte পড়ল (FF), ঠিক তখন interrupt এসে counter-কে 0x00000100 বানাল, তারপর লুপ বাকি byte-গুলো পড়ল (01). হাতে এলো 0x000001FF — এমন একটি মান, যা counter কখনো ছিলই না। একে বলে torn read, পর্ব ৪৯-এর race condition-এর হার্ডওয়্যার সংস্করণ।

সমাধান হলো ছোট একটি critical section: পড়ার মুহূর্তটুকু interrupt বন্ধ রাখা।

__disable_irq();            /* CMSIS (ARM); AVR-এ cli() */
uint32_t now = ticks;       /* পুরো মান নিরাপদে কপি */
__enable_irq();             /* AVR-এ sei() */

এখানে mutex নেই, thread নেই — মূল লুপ আর ISR-এর মাঝে একমাত্র তালা হলো “interrupt বন্ধ”। তবে তালা যত লম্বা, interrupt তত দেরিতে সাড়া পায়; তাই critical section কয়েক নির্দেশের বেশি লম্বা করা চলবে না।

৬ · বাটনের কাঁপুনি — debounce আর state machine

প্রথমবার বাটন দিয়ে counter বানালে প্রায় সবাই একটি অদ্ভুত জিনিস দেখেন: একবার চাপলে counter ৩ বা ৫ বেড়ে যায়! কোড ঠিক, দোষ বাটনের। বাটনের ভেতরে দুটি ধাতব পাত। চাপ দিলে তারা ঠোকাঠুকি খেয়ে কয়েক মিলিসেকেন্ড কাঁপে — লেগে যায়, ছিটকে যায়, আবার লাগে। মানুষের চোখে এক চাপ, কিন্তু মাইক্রোসেকেন্ডে পিন পড়া চিপের কাছে সেটা অনেকগুলো চাপ। এই সমস্যার সমাধানকে বলে debouncing.

সফটওয়্যারে debounce-এর একটি পরিষ্কার উপায় হলো state machine. প্রোগ্রাম সবসময় চারটি অবস্থার একটিতে থাকে: UP (ছাড়া), MAYBE_DOWN (চাপা মনে হচ্ছে), DOWN (নিশ্চিত চাপা), MAYBE_UP (ছাড়া মনে হচ্ছে)। প্রতি ৫ ms-এ টাইমারের টিকে একবার পিন পড়া হয়, আর পরপর দুবার একই মান এলে তবেই পরিবর্তন মেনে নেওয়া হয়। নিচে একটি কাঁপা সংকেত 0, 1, 0, 1, 1, 1, 1:

এবার একই state machine C-তে, একটি নির্দিষ্ট নমুনা-তালিকার ওপর। আসল চিপে raw[i]-এর জায়গায় থাকত টাইমারের প্রতি টিকে পড়া GPIOA->IDR-এর একটি বিট:

#include <stdio.h>
enum state { UP, MAYBE_DOWN, DOWN, MAYBE_UP };

int main(void) {
    const int raw[] = {0,1,0,1,1,1,1,1,0,1,0,0,0,0,1,1,1,0,0,0}; /* every 5 ms */
    enum state s = UP;
    int presses = 0, edges = 0;
    for (int i = 0; i < 20; i++) {
        const int r = raw[i];
        if (i > 0 && r && !raw[i - 1]) edges++;      /* naive: every 0->1 */
        enum state prev = s;
        switch (s) {
        case UP:         s = r ? MAYBE_DOWN : UP; break;
        case MAYBE_DOWN: s = r ? DOWN : UP;       break;
        case DOWN:       s = r ? DOWN : MAYBE_UP; break;
        case MAYBE_UP:   s = r ? DOWN : UP;       break;
        }
        if (prev == MAYBE_DOWN && s == DOWN) printf("t=%3d ms  PRESS %d\n", i * 5, ++presses);
    }
    printf("raw 0->1 edges: %d, real presses: %d\n", edges, presses);
    return 0;
}

৭ · ছোট চিপের কড়া নিয়ম — malloc নেই, printf নেই, float নেই

২ KB RAM-এ বেঁচে থাকতে হলে আপনার অভ্যাসগুলো বদলাতে হবে। নিচের প্রতিটি নিয়মের পেছনে একটি বাস্তব কারণ আছে।

Fixed-point — দশমিক ছাড়া দশমিকের হিসাব

পর্ব ০৮-এ দেখেছেন, টাকাকে পয়সায় গুনলে দশমিক ছাড়াই নির্ভুল হিসাব হয়। Embedded জগতে এই কৌশলের নাম fixed-point. একটি তাপমাত্রা সেন্সর (LM35-এর মতো, যা প্রতি °C-এ ১০ mV দেয়) একটি ১০ বিটের ADC-তে জোড়া, রেফারেন্স ভোল্টেজ ৫ V. ADC পড়ল 62. তাপমাত্রা কত? float ছাড়া হিসাবটি ধাপে ধাপে দেখুন:

uint32_t mv  = ((uint32_t)adc * 5000u + 512u) >> 10;   /* 303 */
int16_t  t10 = (int16_t)mv;                 /* LM35: 10 mV = 1 C */
uart_printf("%d.%d C", t10 / 10, t10 % 10); /* "30.3 C" */

Watchdog — প্রোগ্রাম আটকালে কে উদ্ধার করবে?

ল্যাপটপে প্রোগ্রাম আটকালে আপনি Task Manager খুলে বন্ধ করেন। কিন্তু পাহাড়ের চূড়ায় বসানো একটি আবহাওয়া সেন্সর আটকালে কে বন্ধ করবে? উত্তর watchdog timer: চিপের ভেতরের একটি স্বাধীন টাইমার, যা উল্টো দিকে গুনছে। প্রোগ্রামকে নিয়মিত তাকে “kick” করতে হয় (গোনা আবার শুরু করাতে হয়)। কোনো লুপে আটকে গেলে kick আসবে না, গোনা শূন্যে পৌঁছাবে, আর watchdog পুরো চিপ reset করে দেবে।

for (;;) {
    read_sensors();
    control_motor();
    watchdog_kick();     /* “আমি বেঁচে আছি” — না বললে চিপ reset */
}

সতর্কতা: kick শুধু লুপের এক জায়গায় রাখুন, যেখানে পৌঁছানো মানে সব কাজ ঠিকঠাক হয়েছে। টাইমার ISR-এর ভেতরে kick বসালে মূল লুপ আটকে থাকলেও ISR চলতে থাকবে, watchdog কখনো কামড়াবে না — পাহারাদার ঘুমিয়ে পড়বে।

বিদ্যুৎ বাঁচানো — ঘুমিয়ে থাকাই কাজ

একটি ব্যাটারিচালিত সেন্সর হয়তো প্রতি মিনিটে একবার তাপমাত্রা পাঠায়। বাকি ৫৯ সেকেন্ড CPU জেগে থাকলে ব্যাটারি কয়েক দিনে শেষ। তাই চিপকে sleep mode-এ পাঠানো হয়: CPU আর অপ্রয়োজনীয় peripheral বন্ধ, খরচ মাইক্রোঅ্যাম্পিয়ারে নেমে আসে, আর একটি টাইমার বা বাটনের interrupt তাকে জাগায়। ARM Cortex-M-এ একটি নির্দেশেই (__WFI(), “wait for interrupt”) CPU ঘুমিয়ে পড়ে। ভালো নকশায় এমন যন্ত্র একটি ছোট ব্যাটারিতে মাস থেকে বছর পর্যন্ত চলতে পারে।

৮ · টুলচেইন, ডিবাগিং আর নিরাপত্তার মান

পর্ব ০৩-এর চার ধাপের toolchain এখানেও আছে, তবে একটি মোড় নিয়ে। আপনার ল্যাপটপের CPU x86 বা ARM64, আর লক্ষ্য চিপ AVR বা Cortex-M. তাই এমন একটি compiler লাগে, যা ল্যাপটপে চলে কিন্তু অন্য CPU-র machine code বানায় — একে বলে cross-compiler. ARM-এর জন্য arm-none-eabi-gcc (“none” মানে কোনো OS নেই), AVR-এর জন্য avr-gcc.

# ARM Cortex-M4 (উদাহরণ: STM32F401)
arm-none-eabi-gcc -mcpu=cortex-m4 -mthumb -Os -T stm32f401.ld startup.s main.c -o blink.elf
arm-none-eabi-objcopy -O binary blink.elf blink.bin

# AVR (Arduino Uno), তারপর bootloader দিয়ে flash-এ লেখা
avr-gcc -mmcu=atmega328p -Os -DF_CPU=16000000UL blink.c -o blink.elf
avr-objcopy -O ihex blink.elf blink.hex
avrdude -c arduino -p m328p -P COM3 -b 115200 -U flash:w:blink.hex

• Linker script (-T stm32f401.ld): ল্যাপটপে OS ঠিক করে প্রোগ্রাম মেমরির কোথায় বসবে। এখানে আপনাকেই বলতে হয়: flash শুরু 0x08000000, RAM শুরু 0x20000000, কোড যাবে flash-এ, ভ্যারিয়েবল RAM-এ।
• Startup code আর vector table: চিপ চালু হলে CPU flash-এর শুরুর vector table পড়ে — প্রথম ঘর থেকে stack-এর শুরুর ঠিকানা, দ্বিতীয় ঘর থেকে reset handler-এর ঠিকানা। Reset handler (startup code) প্রাথমিক মানওয়ালা ভ্যারিয়েবল flash থেকে RAM-এ কপি করে, বাকি global ভ্যারিয়েবল শূন্য করে, তারপর main-কে ডাকে। পর্ব ০৪-এ যে প্রশ্ন ছিল — “main-এর আগে কী চলে?” — এখানে তার উত্তর আপনার নিজের প্রজেক্টেই দেখা যায়।
• Flash-এ লেখা: একটি programmer যন্ত্র (যেমন ST-Link) দিয়ে, অথবা চিপে আগে থেকে রাখা bootloader দিয়ে USB-serial পথে। Arduino-র “Upload” বোতাম ভেতরে ঠিক avrdude আর bootloader-ই ব্যবহার করে।
• Debug: SWD বা JTAG পথে ল্যাপটপের gdb সরাসরি চিপের CPU থামাতে, breakpoint বসাতে আর রেজিস্টার পড়তে পারে — পর্ব ৩১-এর gdb, শুধু অপর প্রান্তে একটি আসল চিপ (সাধারণত OpenOCD নামের একটি সংযোগ-প্রোগ্রামের মাধ্যমে)।

নিরাপত্তা যেখানে জীবন — MISRA C আর undefined behavior

পর্ব ৪৬-এ দেখেছেন, undefined behavior মানে “যা খুশি ঘটতে পারে”। ল্যাপটপে তার ফল একটি crash. ব্রেক কন্ট্রোলারে তার ফল দুর্ঘটনা। তাই গাড়ি, বিমান, চিকিৎসা-যন্ত্রের কোড লেখা হয় কড়া নিয়ম মেনে। সবচেয়ে পরিচিত নিয়মের সংকলন MISRA C — ব্রিটেনের Motor Industry Software Reliability Association ১৯৯৮ সালে প্রথম প্রকাশ করে, পরে ২০০৪ ও ২০১২ সালে বড় সংস্করণ আসে। এর কিছু নিয়ম: dynamic memory (malloc) নিষেধ, recursion নিষেধ, প্রতিটি switch-এ default বাধ্যতামূলক, signed আর unsigned-এর লুকানো মিশ্রণ নিষেধ। উদ্দেশ্য একটাই: কোড এমন হবে যার আচরণ টুল দিয়ে প্রমাণ করা যায়।

৯ · AI-এর যুগে embedded কোড — compile হলেই চলবে না

AI দিয়ে embedded কোড লেখানো খুবই লোভনীয়, আর অনেক সময় কাজেও লাগে। কিন্তু এখানে একটি বিশেষ বিপদ আছে: ল্যাপটপের কোডে ভুল হলে প্রোগ্রাম crash করে, আপনি দেখতে পান। Embedded কোডে ভুল হলে প্রায়ই কিছুই ঘটে না — LED জ্বলে না, অথবা সপ্তাহে একবার যন্ত্র আটকে যায়। আর AI আপনার চিপের datasheet পড়েনি; সে ইন্টারনেটের হাজারো আলাদা চিপের কোড মিশিয়ে উত্তর বানায়।

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

• প্রতিটি রেজিস্টারের ঠিকানা ও বিটের অর্থ নিজের চিপের datasheet/reference manual-এ মিলিয়েছি
• Peripheral-এর clock চালু আর পিনের মোড ঠিক করা আছে
• ISR আর main-এর ভাগ করা প্রতিটি ভ্যারিয়েবল volatile, আর একাধিক byte-এর মান পড়ার সময় critical section আছে
• প্রতিটি ISR ছোট, তাতে printf/delay নেই, আর interrupt flag মোছা হয়
• malloc আর অপ্রয়োজনীয় float নেই; build-এর পর flash আর RAM-এর হিসাব দেখেছি
• সম্ভব হলে লজিকটুকু (debounce, state machine, fixed-point) ল্যাপটপে অনুকরণ করে পরীক্ষা করেছি — এই পর্বের দুটি কোডের মতো