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

মাইক্রোপ্রসেসর, এমবেডেড সিস্টেম ও IoT-এর মানচিত্র — কোর্সে কী, কেন আর কীভাবে

A Map of Microprocessors, Embedded Systems and IoT — What the Course Covers, Why It Matters and How to Use It

Taught in Bangla, this lesson explains what microprocessors, microcontrollers, embedded systems and IoT are and how they relate. A four-instruction 8085 program is assembled in the course's 8085 simulator and traced through fetch, decode and execute, totalling 32 T-states (10.67 µs at 3 MHz). It introduces the course's smart scale and cold-storage monitor, maps the 85-lesson, 14-module course with three reading paths, lists what the lab runs and does not run, and gives a checklist for AI answers.

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

  • Microprocessor, microcontroller, embedded system আর IoT কী, আর এদের মধ্যে সম্পর্ক কোথায়
  • একটি 8085 নির্দেশ machine cycle আর T-state ধরে কীভাবে fetch, decode আর execute হয়, আর মোট সময় কীভাবে হিসাব করতে হয়
  • বাজারঘরের smart scale আর cold-storage monitor-এর নির্দিষ্ট নিয়ম ও সংখ্যা, আর load cell থেকে MQTT পর্যন্ত data-র পথ
  • কোর্সের ১৪টি মডিউলের মানচিত্র আর নিজের লক্ষ্য অনুযায়ী তিনটি পড়ার পথের একটি বেছে নেওয়া
  • কোর্সের lab কী চালায় আর কী চালায় না, আর AI assistant-এর embedded-বিষয়ক উত্তর কীভাবে যাচাই করবেন

১ · চারপাশের অদৃশ্য কম্পিউটার — কেন এই কোর্স

সকালে আপনি বাজারে গেলেন। মাছওয়ালার ডিজিটাল দাঁড়িপাল্লা ওজন দেখাল, মোবাইলে bKash-এর বার্তা এল, বাসায় ফিরে প্রিপেইড মিটারে টাকা ভরলেন, আর রাতে Wi-Fi router সারা রাত জ্বলে থাকল। এই প্রতিটি যন্ত্রের ভেতরে একটি ছোট কম্পিউটার আছে, যাকে কেউ “কম্পিউটার” বলে ডাকে না। তার কোনো কি-বোর্ড নেই, পর্দা নেই, সে শুধু একটি কাজ করে, আর বছরের পর বছর না থেমে করে। এমন যন্ত্রকে বলে embedded system: বড় একটি যন্ত্রের ভেতরে বসানো, নির্দিষ্ট কাজের কম্পিউটার।

এই কোর্সের নামের তিনটি অংশ আসলে একটি গল্পের তিন অধ্যায়:

Microprocessor

একটি chip-এ পুরো CPU, কিন্তু মেমরি আর input-output বাইরে আলাদা chip-এ। Microprocessor-এর ক্লাসিক উদাহরণ Intel 8085 আর 8086; এদের দিয়ে CPU-র ভেতরের কাজ সবচেয়ে স্পষ্ট দেখা যায়।

মডিউল ২–৪

Microcontroller

CPU, flash মেমরি, RAM, timer, ADC, UART সব একটি chip-এ। একেই বলে microcontroller (MCU). দাঁড়িপাল্লা থেকে গাড়ি, প্রায় সব embedded যন্ত্র এতেই চলে।

মডিউল ৫–১১

IoT

যখন embedded যন্ত্র network-এ যুক্ত হয়ে তথ্য পাঠায় আর নির্দেশ নেয়, তখন সেটি IoT (Internet of Things)-এর অংশ। এখানে প্রশ্ন ওঠে protocol, battery আর নিরাপত্তার।

মডিউল ১২–১৩

Firmware

এই chip-গুলোর ভেতরে স্থায়ীভাবে রাখা প্রোগ্রামের নাম firmware. এই কোর্সে আপনি assembly আর C-তে firmware লিখবেন, চালাবেন আর ভুল খুঁজবেন।

পুরো কোর্স

একটি পুরোনো রেলস্টেশনের কথা ভাবুন। স্টেশন মাস্টার (microprocessor) খুব বুদ্ধিমান, কিন্তু তাঁর খাতা, ঘণ্টা আর সিগন্যাল আলাদা ঘরে; প্রতিটি কাজে লোক পাঠাতে হয়। এখন একটি ছোট স্টেশনের কথা ভাবুন, যেখানে একজন কর্মীর টেবিলেই খাতা, ঘণ্টার দড়ি আর সিগন্যালের হাতল (microcontroller). তিনি স্টেশন মাস্টারের মতো বড় কাজ পারেন না, কিন্তু নিজের কাজটি একাই, কম খরচে আর নির্ভুলভাবে করেন। আর যখন সেই স্টেশন টেলিফোনে বড় স্টেশনকে প্রতি ঘণ্টায় খবর দেয়, তখন সেটি একটি network-এর অংশ (IoT).

কেন এসব জানা দরকার, যখন Arduino-র একটি library ডেকেই LED জ্বালানো যায়? কারণ library-র নিচে যা ঘটে, তা না জানলে প্রথম কঠিন bug-এ আটকে যাবেন: button চাপলে দুবার গোনা হয়, sensor-এর মান মাঝে মাঝে লাফায়, battery এক সপ্তাহে শেষ, device মাসে একবার আটকে যায়। এই কোর্সের লক্ষ্য তিন ধরনের পাঠকের জন্য একই ভিত্তি তৈরি করা: যিনি নিজে device বানান (maker), যিনি Microprocessors, Embedded Systems বা IoT বিষয় পড়ছেন, আর যিনি চাকরির লিখিত পরীক্ষা বা firmware ইন্টারভিউর প্রস্তুতি নিচ্ছেন।

মূল ধারণা

সাধারণ কম্পিউটারের প্রোগ্রামে ভুল ফলই একমাত্র ব্যর্থতা। Embedded firmware-এ আরও তিনটি আছে: দেরিতে আসা সঠিক ফল (যেমন alarm দশ সেকেন্ড পরে বাজা), বেশি বিদ্যুৎ খরচ (battery দ্রুত শেষ), আর আটকে যাওয়া (কেউ restart করার নেই)। তাই এই কোর্সে প্রতিটি হিসাবের সঙ্গে সময়, শক্তি আর নির্ভরযোগ্যতার প্রশ্নও আসবে। সময়ের এই দাবির নাম real-time, যা মডিউল ৯-এ বিস্তারিত।

২ · ১৯৭৬ থেকে আজ — 8085 থেকে Cortex-M আর IoT

এই কোর্স ইতিহাসের পথ ধরে চলে, কারণ প্রতিটি ধাপ পরের ধাপকে বুঝতে সাহায্য করে। শুরু Intel 8085 দিয়ে, যা ১৯৭৬ সালে বাজারে আসে। এটি ৮-বিটের microprocessor: একবারে ৮ বিট data নিয়ে কাজ করে, আর ১৬টি ঠিকানার তার দিয়ে 64 KB মেমরির যেকোনো ঘর ধরতে পারে। এর ভেতরে আছে কয়েকটি register, যার প্রধানটি হিসাবের ঘর accumulator (A), আর হিসাবের ফলের চিহ্ন রাখার flag register. 8085-এর নির্দেশ লেখা হয় assembly language-এ, যেমন MVI A,49H.

১৯৭৮ সালে আসে ১৬-বিটের Intel 8086, যার ২০টি ঠিকানার তার 1 MB মেমরি ধরতে পারে। এর একটু সস্তা রূপ 8088 দিয়ে ১৯৮১ সালে IBM PC তৈরি হয়, আর সেখান থেকেই আজকের x86 পরিবার। প্রায় একই সময়ে অন্য দিকে আরেকটি ধারা বাড়ছিল: যন্ত্রের ভেতরে বসানোর জন্য পুরো কম্পিউটার এক chip-এ। ১৯৮৫ সালে Acorn-এর ARM, ১৯৯০-এর দশকের শেষে AVR, ২০০৪–০৫ সালে ARM-এর Cortex-M3, ২০০৫ সালে Arduino, আর ২০১৪ ও ২০১৬ সালে Wi-Fi-সহ ESP8266 ও ESP32. আজ একটি সাধারণ microcontroller-এর ভেতরে CPU, flash, RAM আর ডজনখানেক peripheral থাকে, আর ESP32-এর মতো chip-এ radio-ও।

দিক8085 (১৯৭৬)8086 (১৯৭৮)Cortex-M3 MCUESP32 (২০১৬)
Data-র চওড়া৮ বিট১৬ বিট৩২ বিট৩২ বিট
ঠিকানার জায়গা64 KB (১৬ তার)1 MB (২০ তার)4 GB ঠিকানা (৩২ বিট)৩২-বিট ঠিকানা
Clock (সাধারণ রূপ)3 MHz5–10 MHzchip-ভেদে আলাদা; যেমন STM32F103-এ সর্বোচ্চ 72 MHz240 MHz পর্যন্ত
Chip-এর ভেতরে মেমরিনেইনেইflash আর SRAMSRAM; flash সাধারণত পাশের chip-এ
Peripheralবাইরে (8255, 8253…)বাইরে (8259, 8237…)ভেতরে: GPIO, timer, ADC, UART…ভেতরে, সঙ্গে Wi-Fi আর Bluetooth
এই কোর্সে কীভাবেsim8085 (মডিউল ২)NASM + Unicorn (মডিউল ৩)virtual বাজারঘর board (মডিউল ৫–১১)বিষয় হিসেবে (মডিউল ৫, ১২)

শেষ দুই কলামের সংখ্যা chip-ভেদে বদলায়; এখানে সাধারণ রূপ দেখানো হলো, প্রতিটি chip-এর আসল সংখ্যা তার datasheet-এ। একটি কথা আগেই বলে রাখি। এই পাতায় hex লেখার দুই রীতি দেখবেন। 8085 আর 8086-এর পর্বে Intel-এর রীতি: শেষে H, যেমন 2050H (অক্ষর দিয়ে শুরু হলে সামনে 0, যেমন 0F0H). C আর ARM-এর পর্বে C-র রীতি: সামনে 0x, যেমন 0x40021000. দুটিই hexadecimal, শুধু লেখার ধরন আলাদা।

একটি chip-এ পুরো CPU-র প্রথম বাণিজ্যিক উদাহরণ হিসেবে সাধারণত ১৯৭১ সালের ৪-বিটের Intel 4004-কে ধরা হয়, যা একটি জাপানি ক্যালকুলেটর কোম্পানির জন্য নকশা করা হয়েছিল। তারপর 8008 (১৯৭২), 8080 (১৯৭৪) আর 8085 (১৯৭৬)। 8085-এর নামের “5” সম্পর্কে প্রচলিত ব্যাখ্যা হলো, এটি একটিমাত্র +5 V সরবরাহে চলত, যেখানে 8080-এর কয়েকটি আলাদা voltage লাগত। পুরো ইতিহাস, Z80, 68000, 8051, PIC, AVR আর RISC-V microcontroller-সহ, পর্ব ০২-এ (Microprocessor-এর ইতিহাস) দেখবেন; Computer Architecture কোর্সের পর্ব ০২-এ আছে কম্পিউটারের সাধারণ ইতিহাস।

8085 আর 8086 আজ কোনো নতুন পণ্যে বসানো হয় না। তাহলে শুরু এখানে কেন? কারণ এদের সব কাজ চোখের সামনে: প্রতিটি bus-এর তার, প্রতিটি clock-এর টিক, প্রতিটি নির্দেশের সময় খাতায় হিসাব করা যায়। আধুনিক Cortex-M-এ একই কাজ ঘটে, কিন্তু chip-এর ভেতরে লুকিয়ে। আর বিশ্ববিদ্যালয়ের Microprocessors বিষয়ে আর চাকরির লিখিত পরীক্ষায় 8085/8086-এর প্রশ্ন এখনো খুব প্রচলিত। এই বিতর্ক ভাবনার প্রশ্ন ০১-এ আরও গভীরে আছে।

৩ · প্রথম স্বাদ — চার নির্দেশের একটি 8085 program

কথা অনেক হলো, এবার একটি আসল program. দুটি সংখ্যা যোগ করে ফল মেমরিতে রাখা: দশমিকে 73 + 86 = 159, hex-এ 49H + 56H = 9FH. এই program-এর প্রতিটি লাইন একটি নির্দেশ, আর প্রতিটি নির্দেশ মেমরিতে এক থেকে তিনটি byte হয়ে বসে। প্রথম byte-টি নির্দেশের ধরন বলে, যাকে বলে opcode; বাকিগুলো তার data বা ঠিকানা।

; first taste: 49H + 56H, result stored at 2052H
;@show 2052H 1
        ORG 2000H
START:  MVI A,49H       ; A <- 49H
        ADI 56H         ; A <- A + 56H
        STA 2052H       ; [2052H] <- A
        HLT

ORG 2000H বলে program মেমরির কোন ঠিকানা থেকে বসবে; কোর্সের রীতিতে 8085-এর program শুরু হয় 2000H-এ, আর data থাকে 2050H-এর কাছে। MVI A,49H মানে A-তে সরাসরি 49H রাখা (Move Immediate), ADI 56H মানে A-র সঙ্গে 56H যোগ (Add Immediate), STA 2052H মানে A-র মান 2052H ঠিকানায় লেখা (Store Accumulator), আর HLT মানে থামা (Halt). ;@show লাইনটি কোর্সের simulator-এর জন্য একটি মন্তব্য, CPU এটি দেখে না। কোর্সের 8085 simulator sim8085.py-এর asm command এই লেখাকে byte-এ অনুবাদ করে দেখায়; এই কাজের প্রোগ্রামকে বলে assembler (সত্যিকারের run, Python 3.13.5):

$ python -B sim8085.py asm first.asm
2000  3E 49     MVI A,49H
2002  C6 56     ADI 56H
2004  32 52 20  STA 2052H
2007  76        HLT
Start: 2000H   Bytes: 8

(এখানে listing থেকে লাইন নম্বর আর মন্তব্য বাদ দেওয়া হয়েছে।) খেয়াল করুন, STA 2052H-এর ঠিকানা মেমরিতে উল্টো ক্রমে বসেছে: আগে নিচের byte 52, তারপর ওপরের byte 20. 8085 এভাবেই ঠিকানা রাখে (little-endian), যা পর্ব ০৫-এ (এমবেডেড কাজের সংখ্যা) বিস্তারিত।

একটি নির্দেশের ভেতরে: fetch, decode, execute

CPU প্রতিটি নির্দেশে তিনটি কাজ বারবার করে: মেমরি থেকে নির্দেশ আনা (fetch), বুঝে নেওয়া (decode), আর কাজটি করা (execute). এই চক্রের নাম fetch–decode–execute cycle. পরের নির্দেশ কোন ঠিকানায়, তা মনে রাখে program counter (PC). 8085-এ প্রতিটি মেমরি-পড়া বা লেখা একটি machine cycle, আর প্রতিটি machine cycle কয়েকটি clock-টিকে ভাগ করা, যার প্রতিটিকে বলে T-state. ঠিকানা যায় address bus দিয়ে, data আসে data bus দিয়ে। নিচের stepper-এ প্রথম নির্দেশ MVI A,49H-এর সাতটি T-state একটি একটি করে দেখুন।

20003E   ; MVI A (opcode)200149   ; data byte2002C6   ; ADI (পরের নির্দেশ)
Bus আর register
cycle
address
ALE
RD̅
data bus
IR
A
PC
T মোট
  1. M1 (opcode fetch), T1. PC-র মান 2000H address bus-এ যায়। 8085-এ ঠিকানার নিচের ৮ বিট আর data একই আটটি তার (AD0–AD7) ভাগ করে, তাই ALE (Address Latch Enable) সংকেত 1 হয়ে বাইরের একটি latch-কে বলে “নিচের byte 00H ধরে রাখুন”।
  2. M1, T2. RD̅ (read, 0 হলে সক্রিয়) নেমে যায়। মেমরি 2000H ঘরের byte 3EH আটটি তারে রাখে। একই তার এখন data বহন করছে, ঠিকানা নয়; ঠিকানার নিচের অংশ latch-এ ধরা আছে বলে মেমরি তা হারায় না।
  3. M1, T3. CPU 3EH-কে নিজের instruction register (IR)-এ তোলে, আর T3-এর শেষে RD̅ আবার 1 হয়। নির্দেশটি এখন CPU-র ভেতরে।
  4. M1, T4: decode. Control unit 3EH পড়ে বোঝে: এটি MVI A, আর data-র জন্য আরেকটি byte পড়তে হবে। এই T-state-এ bus-এ কিছু ঘটে না। Opcode fetch শেষে PC পরের ঘর 2001H দেখায়। Opcode fetch-এ মোট ৪টি T-state লাগে।
  5. M2 (memory read), T1. দ্বিতীয় machine cycle শুরু। এবার ঠিকানা 2001H, আবার ALE দিয়ে নিচের byte latch হয়।
  6. M2, T2. RD̅ নামে, মেমরি 2001H-এর byte 49H data bus-এ রাখে।
  7. M2, T3: execute. 49H সোজা A register-এ যায়, PC হয় 2002H. মোট ২টি machine cycle, ৭টি T-state (4 + 3). 3 MHz clock-এ এক T-state 1 ÷ 3 MHz = 0.333 µs, তাই এই নির্দেশে লাগে 7 × 0.333 µs ≈ 2.33 µs. কোনো flag বদলায়নি, কারণ MVI শুধু মান রাখে, হিসাব করে না।

এই সূক্ষ্ম ছবিটি (কোন T-state-এ কোন তারে কী থাকে) পরীক্ষায় খুব প্রচলিত “timing diagram” প্রশ্নের ভিত্তি, যা পর্ব ০৮-এ (8085-এর pin, machine cycle আর timing diagram) আঁকতে শিখবেন। Control unit কীভাবে opcode থেকে সংকেত বানায়, তার architecture-স্তরের তত্ত্ব Computer Architecture কোর্সের পর্ব ৩৩-এ। এবার পুরো program, এক নির্দেশ এক ধাপে:

2000MVI A,49H2002ADI 56H2004STA 2052H2007HLT
নির্দেশের পরে অবস্থা
A
PC
S Z AC P CY
[2052H]
এই নির্দেশের T
মোট T
  1. MVI A,49H. আগের stepper-এর কাজ: A = 49H, ৭টি T-state. সব flag রিসেটের পরের মতোই 0, কারণ MVI flag ছোঁয় না।
  2. ADI 56H. 49H + 56H = 9FH (73 + 86 = 159). এবার flag বদলায়: S = 1 (ফলের সবচেয়ে বাঁয়ের বিট 1), Z = 0 (ফল শূন্য নয়), AC = 0 (নিচের nibble-এ 9 + 6 = 15, ১৬ পেরোয়নি), P = 1 (9FH = 10011111b, ছয়টি 1, জোড় সংখ্যা), CY = 0 (ফল 255-এর বেশি নয়)। এটিও দুই machine cycle, ৭টি T-state.
  3. STA 2052H. চারটি machine cycle: opcode fetch (4 T), ঠিকানার দুই byte পড়া (3 + 3 T), তারপর 2052H-এ লেখা (3 T); মোট ১৩টি T-state. মেমরির ঘর 2052H এখন 9FH. Flag বদলায় না।
  4. HLT. CPU থামে (৫টি T-state). PC 2008H, অর্থাৎ HLT-এর পরের ঘর। মোট ৩২টি T-state = 32 × 0.333 µs ≈ 10.67 µs. পুরো program, শুরু থেকে শেষ, এক সেকেন্ডের এক লাখ ভাগের এক ভাগের মতো সময়ে।

এবার এই কাজটি নিজের চোখে চালিয়ে দেখুন। নিচের Python কোড একটি খুব ছোট 8085 emulator: শুধু এই চারটি opcode চেনে, কিন্তু সত্যিকারের byte পড়ে, flag হিসাব করে আর T-state গোনে। কোডটি আপনার ব্রাউজারেই আসল CPython-এ চলে (Pyodide), কোনো সার্ভারে নয়। এটি কোর্সের reference simulator sim8085.py-এর অতি ছোট রূপ; পূর্ণটি ২৪৬টি documented opcode চেনে, আর T-state নেয় Intel-এর 8085 user's manual-এর টেবিল থেকে (reference lab-এর Spec decision 1 আর 2).

mem = bytearray(65536)                 # 64 KiB, all 00H
prog = [0x3E, 0x49,                     # 2000H  MVI A,49H
        0xC6, 0x56,                     # 2002H  ADI 56H
        0x32, 0x52, 0x20,               # 2004H  STA 2052H (low byte first)
        0x76]                           # 2007H  HLT
mem[0x2000:0x2000 + len(prog)] = bytes(prog)
A, PC, total = 0x00, 0x2000, 0
S = Z = AC = P = CY = 0

def fetch():                            # read the byte at PC, then PC + 1
    global PC
    b = mem[PC]; PC = (PC + 1) & 0xFFFF
    return b

while True:
    at = PC
    op = fetch()                        # opcode fetch machine cycle
    if op == 0x3E:   A = fetch(); name, t = "MVI A,%02XH" % A, 7
    elif op == 0xC6:
        d = fetch(); r = A + d
        AC = int((A & 0x0F) + (d & 0x0F) > 0x0F)
        CY = int(r > 0xFF); A = r & 0xFF
        S, Z = A >> 7, int(A == 0)
        P = int(bin(A).count("1") % 2 == 0)
        name, t = "ADI %02XH" % d, 7
    elif op == 0x32:
        lo, hi = fetch(), fetch(); addr = hi << 8 | lo
        mem[addr] = A; name, t = "STA %04XH" % addr, 13
    elif op == 0x76: name, t = "HLT", 5
    total += t
    print(f"{at:04X}  {name:10} A={A:02X} PC={PC:04X} "
          f"S={S} Z={Z} AC={AC} P={P} CY={CY}  T={t:2} total={total}")
    if op == 0x76: break
print(f"[2052H] = {mem[0x2052]:02X}H, {total} T-states = {total / 3:.2f} us at 3 MHz")

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

2000  MVI A,49H  A=49 PC=2002 S=0 Z=0 AC=0 P=0 CY=0  T= 7 total=7
2002  ADI 56H    A=9F PC=2004 S=1 Z=0 AC=0 P=1 CY=0  T= 7 total=14
2004  STA 2052H  A=9F PC=2007 S=1 Z=0 AC=0 P=1 CY=0  T=13 total=27
2007  HLT        A=9F PC=2008 S=1 Z=0 AC=0 P=1 CY=0  T= 5 total=32
[2052H] = 9FH, 32 T-states = 10.67 us at 3 MHz

প্রতিটি লাইন আগের stepper-এর একটি ধাপ। while True loop-টিই fetch–decode–execute: fetch() PC-র ঘর পড়ে PC এক বাড়ায়, if/elif শাখা হলো decode, আর শাখার ভেতরের কাজ execute. STA-র ঠিকানা তৈরি হয় hi << 8 | lo দিয়ে, কারণ মেমরিতে আগে নিচের byte. শেষ লাইনে সময়: ৩২ ÷ ৩ = 10.67 µs, কারণ 3 MHz-এ প্রতি µs-এ তিনটি T-state. এখানে us মানে µs (ASCII-তে লেখা)। একটি সতর্কতা: এই ছোট emulator ADI-এর flag ঠিক রাখে, কিন্তু 8085-এর আরও কিছু নির্দেশের flag-নিয়ম আলাদা, যেমন ANA-তে AC সবসময় 1 (Spec decision 4); সেগুলো মডিউল ২-এ।

একই program কোর্সের পূর্ণ simulator-এ (সত্যিকারের run, sim8085.py, Python 3.13.5):

$ python -B sim8085.py run first.asm
A=9F B=00 C=00 D=00 E=00 H=00 L=00 SP=0000 PC=2008
Flags: S=1 Z=0 AC=0 P=1 CY=0   (F=84H)
Memory 2052H..2052H:
  2052H: 9F
Instructions: 4   T-states: 32

দুই বাস্তবায়ন একই ফল দিয়েছে: A = 9FH, [2052H] = 9FH, ৩২টি T-state. F=84H হলো পুরো flag byte: S বিট 7-এ (80H) আর P বিট 2-এ (04H), যোগফল 84H. এই byte-এর বিন্যাস (S Z 0 AC 0 P 0 CY) reference lab-এর Spec decision 3-এ লেখা, আর পর্ব ০৭-এ (8085-এর গঠন) বিস্তারিত। সময়ের হিসাব পরীক্ষার ধাপে লিখলে:

  1. Crystal 6 MHz; 8085 ভেতরে একে ২ দিয়ে ভাগ করে, তাই CPU clock f = 3 MHz.
  2. এক T-state = 1 ÷ f = 1 ÷ (3 × 106 Hz) = 0.333 µs.
  3. মোট T = 7 + 7 + 13 + 5 = 32.
  4. সময় = 32 × 0.333 µs = 10.67 µs (ঠিক মান 32 ÷ 3 µs).

৪ · বাজারঘরের smart scale — ওজন থেকে দাম

পুরো কোর্সে একটি চলমান প্রজেক্ট আছে। “বাজারঘর” একটি কাল্পনিক মুদি দোকান। তাদের দুটি device দরকার: আলু-পেঁয়াজ মাপার একটি smart scale, আর মাছ-সবজির ঠান্ডা ঘরের জন্য একটি cold-storage monitor. প্রথমে 8085 আর 8086-এ এদের সহজ হিসাব, তারপর virtual ARM board-এ আসল firmware, তারপর RTOS, low-power, sensor, IoT আর security; শেষে ক্যাপস্টোনে (পর্ব ৮০) পুরো ব্যবস্থা firmware থেকে cloud পর্যন্ত। প্রতিটি পর্ব হুবহু একই সংখ্যা ব্যবহার করে, যা reference lab-এর README-তে স্থির করা।

বিষয়Smart scale-এর নিয়ম
SensorLoad cell, তার amplifier, আর ১২-বিট ADC (0–4095 count), channel 0
Calibrationখালি পাল্লা = 400 count; 2000 g-এর মাপা বাটখারা = 1800 count (span 1400 count)
গ্রামে রূপান্তরgrams = round((raw − 400) × 2000 ÷ 1400); প্রতি 100 ms-এ চারটি মাপের গড়
সীমা5000 g; বেশি হলে OVERLOAD
TareButton (PA0) চাপলে চলতি ওজন tare হিসেবে জমা; net = gross − tare
দর আর দামআলু 65.50 টাকা/kg = 6550 পয়সা/kg; price_paisa = (net_g × 6550 + 500) ÷ 1000 (পূর্ণসংখ্যা, অর্ধেক হলে ওপরে)
প্রদর্শন আর পাঠানোUART-এ এক লাইন; MQTT topic bazarghar/scale/1/weight, QoS 1, retained

বাজারের পুরোনো দাঁড়িপাল্লার কথা ভাবুন। এক পাল্লায় আলু, অন্য পাল্লায় বাটখারা, আর মাঝের কাঁটা বলে কোনটি ভারী। Smart scale-এ বাটখারার কাজ করে একটি sensor: load cell নামের একটি ধাতব দণ্ড, যা ভারে সামান্য বাঁকে আর তার ওপর বসানো strain gauge-এর রোধ বদলায়। সেই বদল খুব ছোট voltage-এ (millivolt) প্রকাশ পায়, তাই amplifier তা বড় করে, আর ADC সেটিকে একটি সংখ্যায় (count) বদলায়। Firmware সেই সংখ্যা থেকে গ্রাম আর দাম বের করে। নিচের ছবিতে দুটি device-এর পুরো পথ:

বাজারঘরের দুটি device — sensor থেকে dashboard

বাঁয়ে smart scale, ডানে cold-storage monitor; মাঝে একই virtual board-এর firmware

বাজারঘর smart scale আর cold-storage monitor-এর block diagram Load cell ওজন → mV তাপমাত্রা sensor I2C · 0x48 ADC 12-bit 0–4095 count I2C bus 2 byte · 1/16 °C বাজারঘর board (BG-M3) virtual Cortex-M3 · C firmware calibration · tare · দাম · alarm Display (UART) 1250 g · 81.88 Tk Alarm · PA6 > 8.00 বা < 0.00 °C MQTT publish (Wi-Fi) bazarghar/scale/1/weight Broker → dashboard দোকানির ফোন, হিসাবের খাতা
ছবি ১.১ — বাজারঘরের দুটি device-এর block diagram. হলুদ পথ smart scale, নীল পথ cold-storage monitor; দুটিই কোর্সের virtual board-এ চলে।

এবার ঠিক একটি ঘটনা ধরে পুরো পথ হাঁটা যাক। খালি প্লাস্টিকের ঝুড়ি (150 g) রেখে tare চাপা হয়েছে; তারপর ঝুড়িতে আলু দেওয়ায় মোট ওজন 1400 g.

  1. Load cell1400 gভার
  2. ADC1380count
  3. Calibration1400 ggross
  4. Tare1250 gnet
  5. দাম8188পয়সা
  6. Display81.88UART
  7. MQTTQoS 1broker
Load cellভার → ছোট voltage
ঝুড়ি 150 g + আলু 1250 g
মোট ভার = 1400 g
amplifier সংকেত বড় করে ADC-তে দেয়
ADC12-bit, 0–4095
board-এর model: raw = 400 + 0.7 × grams
raw = 400 + 0.7 × 1400 = 400 + 980
    = 1380 count
চারবার মেপে গড়: (4 × 1380 + 2) ÷ 4 = 1380
Calibrationcount → gram
(raw − 400) × 2000 ÷ 1400
= 980 × 2000 ÷ 1400
= 1960000 ÷ 1400 = 1400 g (gross)
Tareঝুড়ির ওজন বাদ
tare = 150 g (button চেপে জমা)
net = 1400 − 150 = 1250 g
1400 ≤ 5000, তাই overload নয়
দামশুধু পূর্ণসংখ্যা
(1250 × 6550 + 500) ÷ 1000
= (8187500 + 500) ÷ 1000
= 8188000 ÷ 1000 = 8188 পয়সা
UARTdisplay-এর লাইন
raw=1380 gross=1400 g tare=150 g
net=1250 g price=81.88 Tk
MQTTbazarghar/scale/1/weight
{"dev":"scale-1","seq":1,
 "gross_g":1400,"tare_g":150,
 "net_g":1250,
 "rate_paisa_per_kg":6550,
 "price_paisa":8188}
  1. ভার। ঝুড়ি আর আলু মিলে 1400 g. Load cell এই ভারে সামান্য বাঁকে, আর তার সংকেত millivolt-এর মাপের। এত ছোট সংকেত সরাসরি মাপা যায় না, তাই amplifier প্রথমে বড় করে।
  2. ADC: voltage থেকে সংখ্যা। ১২-বিট ADC-র ফল 0 থেকে 4095-এর মধ্যে একটি পূর্ণসংখ্যা। কোর্সের virtual board-এর load-cell model-এ raw = 400 + 0.7 × 1400 = 1380 count. Firmware চারবার মেপে গড় নেয়, যাতে ছোট ওঠানামা কমে; এখানে noise নেই, তাই গড়ও 1380.
  3. Calibration: count থেকে গ্রাম। কারখানায় দুটি মাপ নেওয়া হয়েছিল: খালি অবস্থায় 400, 2000 g বাটখারায় 1800. এই দুই বিন্দুর সরলরেখায় 1380 count মানে (1380 − 400) × 2000 ÷ 1400 = 1400 g. এই মান gross ওজন।
  4. Tare: পাত্রের ওজন বাদ। আগে খালি ঝুড়ি রেখে button চাপায় 150 g জমা ছিল। Net = 1400 − 150 = 1250 g. সীমা 5000 g পেরোয়নি।
  5. দাম: পয়সায়, পূর্ণসংখ্যায়। 1250 × 6550 = 8187500; ১০০০ দিয়ে ভাগ করলে 8187.5 পয়সা. নিয়মে অর্ধেক হলে ওপরে, তাই আগে 500 যোগ করে ভাগ: 8188 পয়সা. কোথাও দশমিক সংখ্যা (float) নেই; কেন, তা অংশের শেষের C কোডে দেখবেন।
  6. Display. 8188 পয়সাকে ১০০ দিয়ে ভাগ করে ভাগফল 81 আর ভাগশেষ 88 পাশাপাশি লিখলে 81.88. Firmware এই লাইন UART দিয়ে পাঠায় (UART-এর text ASCII, তাই টাকার বদলে Tk).
  7. MQTT. একই তথ্য JSON আকারে topic bazarghar/scale/1/weight-এ যায়। দোকানির ফোনের app পরে যুক্ত হলেও শেষ মাপটি সঙ্গে সঙ্গে পায়, কারণ বার্তাটি retained. MQTT-র এই ধারণাগুলো পর্ব ৭৩-এ (MQTT — broker, topic, QoS আর retained message).

এবার এই হিসাব নিজে চালিয়ে দেখুন। নিচের কোড firmware-এর হুবহু একই নিয়ম Python-এ লেখে: ADC model, অর্ধেক হলে শূন্য থেকে দূরে গোল করা (div_round), tare আর পয়সায় দাম। পাঁচটি ঘটনা চলে: ঝুড়ি রাখা, tare চাপা, আলু দেওয়া, অতিরিক্ত ভার আর 500 g আলু।

ZERO_RAW, SPAN_RAW, SPAN_G = 400, 1800, 2000   # two-point calibration
CAPACITY_G, RATE = 5000, 6550                  # 5000 g; 65.50 Tk/kg in paisa

def adc_counts(grams):                 # the board's load-cell model (12-bit)
    return max(0, min(4095, round(400 + 0.7 * grams)))

def div_round(n, d):                   # C-style integer division, half away from 0
    return (n + d // 2) // d if n >= 0 else -((-n + d // 2) // d)

def to_grams(raw):
    return div_round((raw - ZERO_RAW) * SPAN_G, SPAN_RAW - ZERO_RAW)

def price_paisa(net_g):                # integer paisa, round half up
    return 0 if net_g <= 0 else (net_g * RATE + 500) // 1000

tare = 0
for load, press_tare in [(150, False), (150, True), (1400, False),
                         (5100, False), (650, False)]:
    raw = adc_counts(load)
    gross = to_grams(raw)
    if press_tare:
        tare = gross
        print(f"TARE set to {tare} g")
    if gross > CAPACITY_G:
        print(f"raw={raw:<5} OVERLOAD: gross={gross} g > {CAPACITY_G} g")
        continue
    net = gross - tare
    p = price_paisa(net)
    print(f"raw={raw:<5} gross={gross:<5} net={net:<5} "
          f"price={p // 100}.{p % 100:02d} Tk")

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

raw=505   gross=150   net=150   price=9.83 Tk
TARE set to 150 g
raw=505   gross=150   net=0     price=0.00 Tk
raw=1380  gross=1400  net=1250  price=81.88 Tk
raw=3970  OVERLOAD: gross=5100 g > 5000 g
raw=855   gross=650   net=500   price=32.75 Tk

প্রথম লাইনে শুধু ঝুড়ি: 150 g-এর দাম 150 × 6550 ÷ 1000 = 982.5 পয়সা, গোল করে 983, অর্থাৎ 9.83 টাকা. Tare-এর পরে net 0, দাম 0. চতুর্থ লাইন stepper-এর 1250 g আর 81.88 টাকা. 5100 g-এ raw 3970, gross 5100, যা 5000-এর বেশি, তাই দাম নয়, OVERLOAD. শেষে মোট 650 g থেকে ঝুড়ির 150 বাদে 500 g, দাম 32.75 টাকা. Python-এর // ঋণাত্মক সংখ্যায় C-র /-এর থেকে আলাদা আচরণ করে, তাই div_round-এ ঋণাত্মক অংশ আলাদা করে লেখা।

এবার আসল firmware. কোর্সের reference lab-এ scale.c নামের C firmware আছে, যা Clang দিয়ে ARM Cortex-M3-এর জন্য compile হয়ে virtual বাজারঘর board-এ চলে। Script ফাইল বলে দেয় কোন সময়ে পাল্লায় কত ভার আর কখন button চাপা (সত্যিকারের run; board.py, Unicorn 2.1.4, firmware Clang 22.1.8 দিয়ে তৈরি):

$ python -B board.py run firmware/build/scale.elf --script firmware/scripts/scale.json
[     0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[     0.0000 ms] > load on the scale: 0 g
[     0.0729 ms] UART: scale ready: zero=400 counts, span=1400 counts per 2000 g, rate=65.50 Tk/kg
[   100.0889 ms] UART: raw=400 gross=0 g tare=0 g net=0 g price=0.00 Tk
[   250.0000 ms] > load on the scale: 150 g
[   300.0978 ms] UART: raw=505 gross=150 g tare=0 g net=150 g price=9.83 Tk
[   420.0000 ms] > button pressed
[   427.0341 ms] UART: TARE set to 150 g
[   470.0000 ms] > button released
[   500.0981 ms] UART: raw=505 gross=150 g tare=150 g net=0 g price=0.00 Tk
[   650.0000 ms] > load on the scale: 1400 g
[   700.1125 ms] UART: raw=1380 gross=1400 g tare=150 g net=1250 g price=81.88 Tk
[   850.0000 ms] > load on the scale: 5100 g
[   900.0529 ms] UART: OVERLOAD: gross=5100 g > 5000 g
[  1050.0000 ms] > load on the scale: 650 g
[  1100.1043 ms] UART: raw=855 gross=650 g tare=150 g net=500 g price=32.75 Tk
[  1201.0103 ms] exit(0) after 9608082 cycles

প্রতিটি সংখ্যা Python-এর হিসাবের সঙ্গে মেলে: 9.83, 81.88, OVERLOAD, 32.75. বাঁয়ের বন্ধনীতে board-এর সময়। > দিয়ে শুরু লাইনগুলো script-এর input, UART: লাইনগুলো firmware-এর পাঠানো লেখা। Button 420 ms-এ চাপা হলেও tare হয়েছে 427 ms-এ, কারণ firmware পরপর ৮টি 1 ms-এর নমুনায় button চাপা দেখার পরই মেনে নেয়; এই কৌশলের নাম debouncing, পর্ব ৪২-এ। মাপ নেওয়া হয় প্রতি 100 ms-এ, তাই 650 ms-এর আলু দেখা গেছে 700 ms-এর মাপে।

সীমা মনে রাখুন: এই board একটি শিক্ষার model, আসল পণ্য নয়। CPU-র নির্দেশ সত্যিকারের ARMv7-M (Unicorn-এর Cortex-M3 model), কিন্তু peripheral Python-এ লেখা, আর প্রতিটি নির্দেশ ঠিক ১টি cycle ধরা হয় (Spec decision 17); আসল Cortex-M3-এ নির্দেশভেদে cycle আলাদা। ADC-র conversion সঙ্গে সঙ্গে শেষ হয় (Spec decision 25). আর ms-এর পরের ছোট অঙ্কগুলো compiler-এর version-এর ওপর নির্ভর করে (Spec decision 30); আসল chip-এর সময়ের হিসাব সবসময় তার datasheet থেকে।

শেষে একটি প্রশ্ন: দাম পয়সায় পূর্ণসংখ্যা হিসেবে কেন? 65.50 দিয়ে সরাসরি গুণ করলে কী হয়? নিচের C program দুই পথে একই হিসাব করে। “চালিয়ে দেখুন” চাপলে এটি Wandbox নামের অনলাইন সেবায় আসল GCC দিয়ে compile হয়ে চলে:

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

#define RATE_PAISA_PER_KG 6550          /* 65.50 Tk per kg */

/* integer paisa, round half up: same rule as the scale firmware */
static int32_t price_paisa(int32_t net_g)
{
    if (net_g <= 0)
        return 0;
    return (net_g * RATE_PAISA_PER_KG + 500) / 1000;
}

int main(void)
{
    const int32_t grams[] = { 150, 1250, 500, 0 };
    for (int i = 0; i < 4; i++) {
        int32_t g = grams[i];
        int32_t p = price_paisa(g);
        double tk = g * 65.50 / 1000.0;  /* the tempting float way */
        printf("%4d g: integer %ld.%02ld Tk | double %.2f Tk\n",
               (int)g, (long)(p / 100), (long)(p % 100), tk);
    }
    return 0;
}

আসল আউটপুট (সত্যিকারের run: ল্যাবে ziglang 0.17.1-এর Clang 22.1.8, -std=c11 -Wall -Wextra -O2, কোনো warning নেই; Wandbox-এর GCC-তেও একই চার লাইন):

 150 g: integer 9.83 Tk | double 9.82 Tk
1250 g: integer 81.88 Tk | double 81.88 Tk
 500 g: integer 32.75 Tk | double 32.75 Tk
   0 g: integer 0.00 Tk | double 0.00 Tk

প্রথম লাইনে দুই পথের ফল আলাদা! গাণিতিকভাবে 150 g-এর দাম ঠিক 9.825 টাকা, আর নিয়মে অর্ধেক হলে ওপরে, তাই 9.83. কিন্তু floating point-এ 9.825 হুবহু রাখা যায় না; binary-তে সবচেয়ে কাছের মানটি 9.825-এর সামান্য নিচে, তাই %.2f গোল করে 9.82 দেয়। এক পয়সার এই পার্থক্য দিনে হাজার বিক্রিতে হিসাবের খাতা মেলাবে না। পয়সায় পূর্ণসংখ্যা রাখার কৌশলের নাম fixed-point: দশমিকের জায়গা আগে থেকে ঠিক (এখানে দুই ঘর)। আরেকটি কারণ: Cortex-M3-এ floating-point hardware নেই, তাই float-এর হিসাব software-এ ধীরে হয়। পুরো বিষয়টি পর্ব ৪০-এ (Fixed-point গণিত)।

৫ · Cold-storage monitor আর IoT — alarm থেকে dashboard

বাজারঘরের দ্বিতীয় device ঠান্ডা ঘরের পাহারাদার। মাছ আর সবজি ভালো রাখতে ঘরের তাপমাত্রা 0.00 °C থেকে 8.00 °C-এর মধ্যে থাকতে হবে। একটি তাপমাত্রা sensor I2C bus দিয়ে (ঠিকানা 0x48) প্রতি 1 s-এ একটি মান দেয়, আর firmware ঠিক করে alarm বাজাবে কি না। alarm-এর তার PA6, যা একটি লাল LED বা buzzer চালায়; এমন output যন্ত্রকে বলে actuator. এখানে দুটি বুদ্ধি আছে, যা বাস্তব যন্ত্রে খুব জরুরি:

  • নিশ্চিত হয়ে তবে বাজানো: একবার 8.00 °C পেরোলেই alarm নয়; পরপর তিনটি মান সীমার বাইরে হলে তবেই। দরজা এক মুহূর্ত খুললে মিথ্যা alarm হবে না।
  • বন্ধ করতে আলাদা সীমা: alarm বন্ধ হয় শুধু যখন পরপর তিনটি মান 0.50 থেকে 7.50 °C-এর মধ্যে। মাঝের 0.50 °C-এর ফাঁককে বলে hysteresis. ঠিক 8.00-এর আশপাশে দোলা তাপমাত্রায় এটি না থাকলে alarm বারবার জ্বলত-নিভত, যেমন ভাঙা ট্রাফিক সিগন্যাল ঘন ঘন রং বদলায়।

প্রতি 10 s-এ device একটি telemetry বার্তা পাঠায়: এখনকার তাপমাত্রা আর alarm-এর অবস্থা। নিচের কোড firmware-এর একই যুক্তি Python-এ লেখে, board-এর script-এর একই কুড়িটি মান নিয়ে:

HIGH, LOW, HYST, CONFIRM = 8.00, 0.00, 0.50, 3   # limits in degC
# one reading per second, t = 1 .. 20 s (the same values as the board's script)
temps = [4.00] * 2 + [5.50] * 2 + [8.25, 9.00, 9.50, 9.50, 7.75] + [7.00] * 5 + [-0.50] * 6

state, high_n, low_n, ok_n = "OFF", 0, 0, 0
for t, temp in enumerate(temps, start=1):
    high_n = high_n + 1 if temp > HIGH else 0          # out of range, high side
    low_n = low_n + 1 if temp < LOW else 0             # out of range, low side
    inside = LOW + HYST <= temp <= HIGH - HYST         # 0.50 .. 7.50: safe band
    ok_n = ok_n + 1 if inside else 0
    want = state
    if high_n >= CONFIRM:
        want = "HIGH"
    elif low_n >= CONFIRM:
        want = "LOW"
    elif state != "OFF" and ok_n >= CONFIRM:
        want = "OFF"
    note = ""
    if want != state:
        state = want
        note = "ALARM OFF" if state == "OFF" else f"ALARM ON: {state} temperature"
    if t % 10 == 0:
        note += f"  TELEMETRY temp_c={temp:.2f} alarm={state}"
    print(f"t={t:2} s T={temp:+.2f} C  high={high_n} low={low_n} ok={ok_n}  {note}".rstrip())

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

t= 1 s T=+4.00 C  high=0 low=0 ok=1
t= 2 s T=+4.00 C  high=0 low=0 ok=2
t= 3 s T=+5.50 C  high=0 low=0 ok=3
t= 4 s T=+5.50 C  high=0 low=0 ok=4
t= 5 s T=+8.25 C  high=1 low=0 ok=0
t= 6 s T=+9.00 C  high=2 low=0 ok=0
t= 7 s T=+9.50 C  high=3 low=0 ok=0  ALARM ON: HIGH temperature
t= 8 s T=+9.50 C  high=4 low=0 ok=0
t= 9 s T=+7.75 C  high=0 low=0 ok=0
t=10 s T=+7.00 C  high=0 low=0 ok=1    TELEMETRY temp_c=7.00 alarm=HIGH
t=11 s T=+7.00 C  high=0 low=0 ok=2
t=12 s T=+7.00 C  high=0 low=0 ok=3  ALARM OFF
t=13 s T=+7.00 C  high=0 low=0 ok=4
t=14 s T=+7.00 C  high=0 low=0 ok=5
t=15 s T=-0.50 C  high=0 low=1 ok=0
t=16 s T=-0.50 C  high=0 low=2 ok=0
t=17 s T=-0.50 C  high=0 low=3 ok=0  ALARM ON: LOW temperature
t=18 s T=-0.50 C  high=0 low=4 ok=0
t=19 s T=-0.50 C  high=0 low=5 ok=0
t=20 s T=-0.50 C  high=0 low=6 ok=0    TELEMETRY temp_c=-0.50 alarm=LOW

5, 6 আর 7 সেকেন্ডে তিনটি মান 8.00-এর ওপরে, তাই 7 s-এ HIGH alarm. 9 s-এর 7.75 °C লক্ষ করুন: এটি 8.00-এর ওপরে নয় (high গণনা 0), আবার 7.50-এর নিচেও নয় (ok গণনা 0). এটিই hysteresis-এর ফাঁক; এই মান alarm বন্ধও করে না। 10, 11, 12 s-এ তিনটি 7.00 °C, তাই 12 s-এ alarm বন্ধ। 15 s থেকে −0.50 °C, আর তিনটি মানের পরে 17 s-এ LOW alarm. Virtual board-এ আসল coldroom.c firmware একই script-এ চালালে (সত্যিকারের run) ঠিক একই মুহূর্ত আসে: [ 7000.0634 ms] UART: ALARM ON: HIGH temperature, [ 12000.0510 ms] UART: ALARM OFF, [ 17000.0646 ms] UART: ALARM ON: LOW temperature, আর 10 s ও 20 s-এ TELEMETRY.

Telemetry-র পথে আসে IoT. MQTT একটি হালকা publish-subscribe protocol: device একটি topic-এ বার্তা “publish” করে, আর যে app সেই topic-এ “subscribe” করেছে, সে বার্তা পায়। মাঝখানে থাকে একটি broker, যেমন পোস্ট অফিস চিঠি নিয়ে ঠিকানা অনুযায়ী বিলি করে। কোর্সের lab নিজের কম্পিউটারেই (127.0.0.1) একটি broker চালায় (Spec decision 37); সেখানে scale-1 ওজন publish করলে dashboard যা পায় (সত্যিকারের run, mqtt_demo.py --quiet, amqtt 0.12.2 আর paho-mqtt 2.2.0, আউটপুটের ধাপ ২):

2. scale-1 publishes a weight reading: QoS 1, retained
    dashboard got bazarghar/scale/1/weight qos=1 retain=0 {"dev":"scale-1","seq":1,"gross_g":1400,"tare_g":150,"net_g":1250,"rate_paisa_per_kg":6550,"price_paisa":8188}
    -> net 1250 g x 65.50 Tk/kg = 8188 paisa = 81.88 Tk

এটি smart scale-এর stepper-এর শেষ ধাপের বার্তা, অক্ষরে অক্ষরে। এখানে retain=0 দেখে অবাক হবেন না: যে subscriber আগে থেকেই যুক্ত, সে বার্তা “নতুন” হিসেবে পায়; retained হিসেবে (retain=1) পায় শুধু পরে যুক্ত হওয়া app. QoS, retained message আর Last Will-এর পুরো গল্প মডিউল ১২-এ। একটি সতর্কতা আগেই: এই demo broker-এ কোনো password বা TLS নেই, কারণ এটি শুধু নিজের যন্ত্রের ভেতরে চলে। আসল দোকানের device-এ এমন খোলা broker বিপজ্জনক; নিরাপদ নকশা পর্ব ৭৬-এ (IoT security).

৬ · কোর্সের মানচিত্র — ১৪টি মডিউল

এবার পুরো কোর্সটি এক নজরে। মডিউলগুলো একটি সিঁড়ির মতো: নিচের ধাপে CPU-র ভেতরের কাজ, মাঝে chip আর তার peripheral, ওপরে সময়, শক্তি আর network. প্রতিটি ধাপে বাজারঘরের device একটু করে বড় হয়।

  1. ভিত্তিM1পর্ব ১–৬
  2. 8085, 8086M2–M3পর্ব ৭–২১
  3. InterfacingM4পর্ব ২২–২৭
  4. MCU, CM5–M6পর্ব ২৮–৪০
  5. PeripheralM7–M8পর্ব ৪১–৫৩
  6. RTOS, powerM9–M10পর্ব ৫৪–৬৪
  7. Sensor, IoTM11–M13পর্ব ৬৫–৮০
  8. প্রস্তুতিM14পর্ব ৮১–৮৫
মডিউল ১বাজারঘর: পরিচয়
মানচিত্র · ইতিহাস · MPU, MCU, SoC
বৈশিষ্ট্য · সংখ্যা · lab
device-এর নিয়ম আর সংখ্যা জানা
মডিউল ২–৩বাজারঘর: assembly-তে হিসাব
M2 8085: register, timing, program,
   stack, interrupt (sim8085)
M3 8086: segment, NASM, string, IVT
ওজনের যোগফল, দামের গুণ assembly-তে
মডিউল ৪বাজারঘর: বাইরের chip
memory decoding · memory-mapped I/O
8255 · 8253/8254 · 8259 · 8251 · 8237
display আর button-এর port
মডিউল ৫–৬বাজারঘর: board-এ firmware
M5 Cortex-M, NVIC, linker, startup
M6 volatile, bit, register, build,
   debugging, stack, fixed-point
BG-M3-এ প্রথম C firmware
মডিউল ৭–৮বাজারঘর: যন্ত্রের অঙ্গ
M7 GPIO, debounce, ISR, timer, PWM, DMA
M8 ADC, DAC, UART, SPI, I2C, CAN, Modbus
tare button, ADC, I2C sensor
মডিউল ৯–১০বাজারঘর: সময় আর শক্তি
M9 real-time, super loop, RTOS task,
   mutex, queue (rtos_sim)
M10 sleep, watchdog, battery, test
দুই কাজ একসঙ্গে, battery-তে মাসের পর মাস
মডিউল ১১–১৩বাজারঘর: network-এ
M11 sensor, calibration, motor, PID
M12 Wi-Fi, BLE, LoRaWAN, MQTT, CoAP
M13 security, secure boot, TinyML
ক্যাপস্টোন: firmware থেকে cloud
মডিউল ১৪পরীক্ষা ও ইন্টারভিউ
8085/8086 সমস্যা · MCQ · লিখিত ও ভাইভা
timer, baud, ADC, power-এর অঙ্ক
firmware ইন্টারভিউর প্রশ্ন
  1. ভিত্তি (মডিউল ১, পর্ব ০১–০৬)। এই মানচিত্র, microprocessor-এর ইতিহাস, microprocessor বনাম microcontroller বনাম SoC, embedded system-এর বৈশিষ্ট্য, binary-hex-BCD-two's complement, আর কোর্সের lab-এর পুরো পরিচয় (পর্ব ০৬)।
  2. ক্লাসিক microprocessor (মডিউল ২–৩, পর্ব ০৭–২১)। 8085-এর গঠন, pin আর timing diagram, instruction set, addressing mode, program, stack, interrupt; তারপর 8086-এর segment আর physical address, NASM-এ আসল program, procedure, string instruction, interrupt vector table আর bus. পরীক্ষার সবচেয়ে প্রচলিত অংশ এখানে।
  3. Interfacing (মডিউল ৪, পর্ব ২২–২৭)। ROM আর RAM-কে ঠিকানা দেওয়া (address decoding), memory-mapped বনাম isolated I/O, আর ক্লাসিক peripheral chip: 8255 PPI, 8253/8254 timer, 8259 interrupt controller, 8251 USART আর 8237 DMA. Control word-এর হিসাব এখানে।
  4. Microcontroller আর embedded C (মডিউল ৫–৬, পর্ব ২৮–৪০)। MCU-র পরিবার, ARM Cortex-M-এর register আর exception, NVIC, memory map আর linker script, reset থেকে main পর্যন্ত; তারপর volatile, bit manipulation, register-এর struct, cross-compiler দিয়ে build, debugging, stack আর fixed-point.
  5. Peripheral (মডিউল ৭–৮, পর্ব ৪১–৫৩)। GPIO, debouncing, interrupt আর ISR, timer, PWM, DMA; তারপর ADC, DAC, UART, SPI, I2C, CAN, USB, RS-485 আর Modbus. Smart scale-এর button আর ADC, cold room-এর I2C sensor এখানে পূর্ণ রূপ পায়।
  6. সময়, শক্তি আর নির্ভরযোগ্যতা (মডিউল ৯–১০, পর্ব ৫৪–৬৪)। Hard আর soft deadline, super loop আর state machine, RTOS-এর task, semaphore, mutex আর queue; তারপর sleep mode, watchdog, battery-র আয়ুর হিসাব, MISRA C আর host-এ unit test.
  7. Sensor, IoT আর security (মডিউল ১১–১৩, পর্ব ৬৫–৮০)। Sensor আর calibration, motor, filter, PID; Wi-Fi, BLE, LoRaWAN, MQTT, CoAP, device management আর OTA update; IoT-এর threat model, secure boot, TinyML, case study, আর ক্যাপস্টোন।
  8. প্রস্তুতি (মডিউল ১৪, পর্ব ৮১–৮৫)। বিশ্ববিদ্যালয়, চাকরি বা ইন্টারভিউর পরীক্ষার জন্য 8085/8086-এর সমস্যা, MCQ প্রশ্নব্যাংক, লিখিত ও ভাইভা, embedded নকশার গাণিতিক সমস্যা আর firmware ইন্টারভিউর প্রশ্ন।
মডিউলবিষয়পর্বমূল lab tool
১ভিত্তি০১–০৬সবগুলোর পরিচয়
২8085 microprocessor০৭–১৩sim8085
৩8086 microprocessor১৪–২১NASM + Unicorn
৪Memory আর peripheral interfacing২২–২৭sim8085, হাতে হিসাব
৫Microcontroller আর ARM Cortex-M২৮–৩৩বাজারঘর board
৬Embedded C আর toolchain৩৪–৪০Clang, বাজারঘর board
৭GPIO, interrupt, timer আর DMA৪১–৪৬বাজারঘর board
৮Analog আর communication interface৪৭–৫৩বাজারঘর board
৯Real-time system আর RTOS৫৪–৫৯rtos_sim
১০Power, নির্ভরযোগ্যতা আর testing৬০–৬৪বাজারঘর board
১১Sensor, actuator আর control৬৫–৬৯বাজারঘর board, Python
১২IoT-এর network আর protocol৭০–৭৫local MQTT, CoAP
১৩Security, edge আর ক্যাপস্টোন৭৬–৮০সব tool একসঙ্গে
১৪পরীক্ষা ও ইন্টারভিউ প্রস্তুতি৮১–৮৫সমস্যা আর প্রশ্নব্যাংক

৭ · তিনটি পড়ার পথ, পূর্বজ্ঞান আর কোর্সের lab

সবার একই গভীরতা দরকার নেই। নিজের লক্ষ্য দেখে একটি পথ বেছে নিন; পরে পথ বদলানোও সহজ, কারণ মডিউলগুলো একে অপরের সঙ্গে স্পষ্টভাবে যুক্ত।

পথমডিউলকার জন্যশেষে যা পারবেন
মেকারের পথ১, ৫–৮, ১১–১২, তারপর ক্যাপস্টোনযিনি Arduino বা ESP32 দিয়ে device বানানregister-স্তরে firmware, sensor, MQTT; library-র নিচে কী ঘটে তা বোঝা
বিশ্ববিদ্যালয়ের পথ১–১০, তারপর ১২–১৩ থেকে বাছাইMicroprocessors, Embedded Systems বা IoT বিষয়ের শিক্ষার্থী8085/8086 program আর interfacing, Cortex-M, RTOS, low-power নকশা
চাকরি আর ইন্টারভিউর পথ১–৪, ৬–৭, ৯, তারপর ১৪IT, programmer বা engineer পদের লিখিত পরীক্ষার্থী, firmware ইন্টারভিউর প্রার্থীtiming আর control word-এর অঙ্ক, volatile, ISR, RTOS-এর প্রশ্নের উত্তর

প্রতিটি পর্বের ভেতরেও তিনটি স্তর থাকে: শুরুতে উদাহরণ আর তুলনা, তারপর নিখুঁত সংজ্ঞা, সূত্র আর পরীক্ষার ধাঁচের সমাধান, শেষে “আরও গভীরে” বাক্স। মেকারের পথে থাকলে “আরও গভীরে” বাদ দিলেও কিছু হারাবেন না।

যা আগে থেকে জানা ভালো। C-তে variable, loop, function আর pointer-এর প্রাথমিক ধারণা: C প্রোগ্রামিং কোর্স; embedded-এর জন্য C-র বিশেষ দিকের একটি পরিচয় তার পর্ব ৫৪-এ। আর binary-hex সংখ্যা আর logic gate-এর ধারণা: Computer Architecture কোর্সের পর্ব ০৪ (সংখ্যা পদ্ধতি) আর পুরো কোর্স, যেখানে bus, interrupt আর DMA-র architecture-স্তরের তত্ত্ব আছে (যেমন পর্ব ৫২)। এই কোর্স সেই তত্ত্ব আবার শেখাবে না; বরং device আর firmware-এর স্তরে কাজে লাগাবে। RTOS-এর জন্য Operating Systems আর MQTT-র নিচের TCP/IP-এর জন্য Computer Networks কোর্স সহায়ক।

কোর্সের lab. আসল board, oscilloscope বা logic analyzer লাগবে না। সব কাজ চলে software-এ, আর প্রতিটি tool কী নকল করে আর কী করে না, তা খোলাখুলি বলা থাকে। পুরো ব্যাখ্যা পর্ব ০৬-এ (কোর্সের lab); এখানে সারাংশ:

Toolকী চালায়সৎ সীমা
sim8085.py8085-এর assembler আর simulator: flag, T-state, interruptbus-এর বৈদ্যুতিক আচরণ নেই; wait state নেই (Spec decision 2)
run8086.pyNASM-এ assemble করা আসল 8086 কোড, Unicorn emulator-এUnicorn আসলে 386-শ্রেণির CPU; চারটি জানা পার্থক্য আছে (Spec decision 15); সময় গোনা হয় না (Spec decision 16)
board.pyvirtual বাজারঘর board (BG-M3): Clang-এ compile করা আসল Cortex-M3 firmware১ নির্দেশ = ১ cycle (Spec decision 17); peripheral সরলীকৃত
rtos_sim.pyRTOS-এর scheduling, mutex, queue, tick ধরেশুধু পূর্ণ tick; আসল RTOS kernel নয় (Spec decision 32)
mqtt_demo.pyনিজের যন্ত্রে MQTT broker আর clientশুধু 127.0.0.1, কোনো password বা TLS নেই (Spec decision 37)

পাতার ভেতরে কোড চলে তিনভাবে: Python (চালিয়ে দেখুন) আপনার ব্রাউজারে Pyodide-এ; JavaScript ব্রাউজারের sandbox-এ; আর C Wandbox-এর আসল compiler-এ, শুধু আউটপুট দেখা যায়। বড় tool-এর আউটপুট আসে “সত্যিকারের run” থেকে, version-সহ। যেখানে কোনো কিছু চালানো যায়নি, সেখানে লেখা থাকবে “উদাহরণ, চালানো হয়নি”; হাতে লেখা আনুমানিক আউটপুটে “নমুনা আউটপুট”। এই লেবেল না থাকলে আউটপুটটি আসল run থেকে নেওয়া। Lab কীভাবে কাজ করে, আর নিজের কম্পিউটারে অনুশীলনের জন্য কোন free tool ব্যবহার করতে পারেন, তা পর্ব ০৬-এ।

আরও গভীরে: 8085-এর ঠিকানার নিচের ৮ বিট আর data একই তার ভাগ করে (AD0–AD7), কারণ ৪০-pin package-এ ১৬টি ঠিকানা আর ৮টি data তার আলাদা করে রাখার জায়গা ছিল না; ALE আর একটি বাইরের latch (যেমন 74LS373) সেই ভাগাভাগি সামলায়। আধুনিক Cortex-M-এ এমন বাইরের bus সাধারণত নেই: CPU, flash, SRAM আর peripheral chip-এর ভেতরে ARM-এর AMBA পরিবারের bus (যেমন AHB আর APB) দিয়ে যুক্ত। কোর্সের virtual board-এ peripheral-গুলো এই কারণেই memory-mapped: ঠিক যেমন আসল chip-এ, একটি ঠিকানায় লেখা মানে একটি hardware register-এ লেখা।

পরীক্ষা ও ইন্টারভিউতে: বিশ্ববিদ্যালয়, চাকরি বা ইন্টারভিউর পরীক্ষায় এই বিষয়ে এমন প্রশ্ন প্রায়ই আসে:

  • Microprocessor আর microcontroller-এর পার্থক্য? Microprocessor-এ শুধু CPU, মেমরি আর I/O বাইরে; microcontroller-এ CPU, মেমরি আর peripheral একই chip-এ, নির্দিষ্ট কাজের জন্য।
  • 8085-এ MVI A,49H-এ কয়টি machine cycle আর T-state? ২টি (opcode fetch + memory read), ৭টি T-state (4 + 3).
  • 3 MHz-এ এক T-state কত? 1 ÷ 3 MHz ≈ 0.333 µs; 8085 crystal-এর frequency ২ দিয়ে ভাগ করে, তাই 6 MHz crystal-এ 3 MHz.
  • Embedded system-এর বৈশিষ্ট্য? নির্দিষ্ট কাজ, সীমিত মেমরি আর শক্তি, real-time দাবি, দীর্ঘ সময় নির্ভরযোগ্যভাবে চলা।
  • একটি IoT device-এর স্তরগুলো কী? Sensor → microcontroller-এর firmware → network (Wi-Fi, BLE, LoRaWAN) → broker বা cloud → app বা dashboard.

৮ · AI-এর যুগে microprocessor আর firmware শেখা

AI assistant এক মিনিটে একটি 8085 program বা একটি Arduino sketch লিখে দিতে পারে। কিন্তু এই বিষয়ে AI-এর ভুল খুব বিশ্বাসযোগ্য শোনায়, আর ভুল firmware শুধু ভুল সংখ্যা দেখায় না: যন্ত্র আটকে যায়, battery শেষ হয়, বা alarm সময়মতো বাজে না। এই বিষয়ে বারবার দেখা ভুলগুলো:

AI-এর ভুলউদাহরণকীভাবে ধরবেন
8085, 8086 আর Z80-এর নির্দেশ মিশিয়ে ফেলা8085-এ ADD 56H (immediate-এর জন্য আসলে ADI), বা 8085-এ Z80-এর LD A,49Hsimulator-এ assemble করা; ভুল নির্দেশে assembler error দেয়
ভুল T-state বা cycle গোনা“STA-তে ৭টি T-state” (আসলে ১৩)Intel-এর manual-এর টেবিল আর simulator-এর T-state
Register-এর নাম বা ঠিকানা বানানোএকটি নির্দিষ্ট MCU-র জন্য না-থাকা register বা ভুল base addressসেই chip-এর reference manual আর datasheet
ISR-এ volatile ভুলে যাওয়া, blocking কাজISR-এর ভেতরে delay বা printf; flag variable-এ volatile নেইcompiler-এর আসল assembly পড়া; পর্ব ৩৪ আর ৪৩-এর নিয়ম
Baud rate, I2C বা SPI-এর হিসাব ভুলভুল divisor, ভুল SPI modeহাতে সূত্র দিয়ে হিসাব, তারপর simulator
অনিরাপদ IoT ডিফল্টকোডে লেখা Wi-Fi password, TLS ছাড়া MQTT, signature ছাড়া updateপর্ব ৭৬–৭৭-এর checklist

AI-কে সহকারী হিসেবে ব্যবহার করুন, শেষ কথা হিসেবে নয়। প্রশ্নে CPU, clock আর tool স্পষ্ট বলে দিন, আর উত্তরের সঙ্গে যাচাইয়ের উপায় চেয়ে নিন:

আমি Intel 8085 (8080 বা Z80 নয়) শিখছি, clock 3 MHz (6 MHz crystal). নিচের program-টি দেখো: [এখানে program পেস্ট করুন] ১. প্রতিটি নির্দেশের পরে A, PC আর S Z AC P CY flag-এর মান টেবিলে দাও। ২. প্রতিটি নির্দেশের machine cycle আর T-state লেখো, Intel 8085 user's manual-এর টেবিল অনুযায়ী; মোট সময় µs-এ হিসাব করো। ৩. কোনো নির্দেশ 8085-এ না থাকলে (যেমন Z80-এর নির্দেশ) স্পষ্ট করে বলো। ৪. কোনো সংখ্যা নিয়ে নিশ্চিত না হলে তা বলো; অনুমানকে তথ্য হিসেবে লিখো না।

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

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

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

প্র ০১১৯৭৬ সালের 8085 আজও কেন পড়ানো হয়, যখন নতুন যন্ত্রে বসে ৩২-বিটের Cortex-M?

প্রশ্নটি ন্যায্য। নতুন কোনো পণ্যে 8085 বসানো হয় না, আর বাস্তবের firmware engineer-এর দৈনন্দিন কাজ চলে ARM Cortex-M, ESP32 বা RISC-V MCU-তে। তবু 8085 শেখার পক্ষে তিনটি শক্ত যুক্তি আছে।

প্রথম যুক্তি দৃশ্যমানতা। 8085-এর প্রতিটি কাজ chip-এর pin-এ দেখা যায়: ঠিকানা কখন bus-এ যায়, ALE কখন ওঠে, RD̅ কখন নামে, কোন T-state-এ data আসে। একটি ছোট নির্দেশের সময়ও খাতায় হিসাব করা যায়, যেমন এই পর্বে MVI A,49H-এ ৭টি T-state. Cortex-M-এ একই ধরনের কাজ ঘটে, কিন্তু chip-এর ভেতরে, pipeline আর ভেতরের bus-এর আড়ালে; সেখানে একটি নির্দেশের cycle-সংখ্যাও অবস্থাভেদে বদলাতে পারে। যিনি 8085-এ machine cycle একবার নিজের হাতে গুনেছেন, তিনি পরে “bus”, “wait state” বা “interrupt latency” শব্দ শুনলে তার ছবি মনে আনতে পারেন।

দ্বিতীয় যুক্তি ধারণার স্থানান্তর। Register, flag, stack, subroutine, interrupt vector, memory-mapped I/O, address decoding: এই ধারণাগুলো 8085 থেকে Cortex-M পর্যন্ত একই থাকে, শুধু আকার আর নাম বদলায়। 8085-এর RST 7.5 আর Cortex-M-এর NVIC-এর মধ্যে প্রায় ৩০ বছরের ব্যবধান, কিন্তু প্রশ্ন একই: কোন interrupt আগে, আর ফেরার ঠিকানা কোথায় রাখা হবে।

তৃতীয় যুক্তি বাস্তব প্রয়োজন: বিশ্ববিদ্যালয়ের Microprocessors বিষয়ে আর চাকরির লিখিত পরীক্ষায় 8085/8086-এর program, timing আর interfacing-এর প্রশ্ন এখনো খুব প্রচলিত। এর বিপক্ষেও যুক্তি আছে: কেবল 8085-এ থেমে গেলে আধুনিক toolchain, C firmware, RTOS বা নিরাপত্তার কিছুই শেখা হয় না। তাই এই কোর্স 8085/8086-কে ভিত্তি হিসেবে রাখে (মডিউল ২–৪), কিন্তু বেশিরভাগ সময় দেয় আধুনিক microcontroller আর IoT-কে।

মূল উপলব্ধি: 8085 শেখা হয় যন্ত্রের মনের ছবি তৈরির জন্য, পুরোনো পণ্য বানানোর জন্য নয়। সেই ছবি নিয়ে আধুনিক chip-এর datasheet পড়া অনেক সহজ হয়।

প্র ০২Microprocessor আর microcontroller-এর পার্থক্য কি শুধু “chip-এ কী আছে”, নাকি এর পেছনে বড় কোনো নকশার সিদ্ধান্ত আছে?

বইয়ের সংজ্ঞায় পার্থক্যটি অংশের তালিকা: microprocessor-এ শুধু CPU, microcontroller-এ CPU-র সঙ্গে মেমরি আর peripheral. কিন্তু এই তালিকার পেছনে আছে একটি মৌলিক প্রশ্ন: যন্ত্রটি কি সাধারণ কাজের, নাকি একটি নির্দিষ্ট কাজের?

সাধারণ কাজের কম্পিউটারে (PC, server) কতটা মেমরি লাগবে কেউ আগে জানে না, তাই মেমরি বাইরে রাখা হয়, যাতে বাড়ানো যায়। গতি সবচেয়ে বড় দাবি, বিদ্যুৎ খরচ দ্বিতীয়। একটি ডিজিটাল দাঁড়িপাল্লার ক্ষেত্রে উল্টো: কাজ আগে থেকে জানা, program কয়েক কিলোবাইট, কিন্তু যন্ত্রটি সস্তা, ছোট আর battery-তে চলতে হবে। তখন সবকিছু এক chip-এ রাখাই বুদ্ধিমানের কাজ: কম অংশ, ছোট board, কম তার, কম বিদ্যুৎ, আর chip-এর বাইরে সংকেত কম যায় বলে বৈদ্যুতিক গোলমালও কম।

এই চিন্তা ১৯৭০-এর দশকেই এসেছিল। অনেক সূত্রে Texas Instruments-এর TMS1000-কে (১৯৭০-এর দশকের মাঝামাঝি) প্রথম দিকের microcontroller বলা হয়; Intel ১৯৭৬ সালে 8048 আর ১৯৮০ সালে 8051 আনে, আর 8051 পরিবার কয়েক দশক ধরে বহু প্রতিষ্ঠান তৈরি করেছে। তারিখ নিয়ে উৎসভেদে সামান্য পার্থক্য আছে।

আজ সীমারেখা আরও ঝাপসা। মোবাইল ফোনের chip একটি SoC: কয়েকটি CPU core, GPU, modem আর মেমরি controller এক chip-এ, কিন্তু মূল RAM পাশের আলাদা chip-এ। আবার ESP32-এর মতো microcontroller-এ Wi-Fi radio-ও ভেতরে। তাই প্রকৌশলের প্রশ্নটি নাম নয়, প্রয়োজন: কত গতি, কত মেমরি, কত বিদ্যুৎ, কোন peripheral, কত বড় board. বাজারঘরের scale-এর জন্য একটি ছোট Cortex-M MCU যথেষ্ট; একই দোকানের ক্যামেরা-ভিত্তিক হিসাব যন্ত্রে লাগবে বড় SoC আর embedded Linux (পর্ব ৫৯)। এই তুলনা পর্ব ০৩-এ বিস্তারিত।

মূল উপলব্ধি: Microcontroller হলো “নির্দিষ্ট কাজের জন্য যথেষ্ট, কিন্তু সবকিছু এক জায়গায়” নীতির ফল। Chip বেছে নেওয়া মানে প্রয়োজনের তালিকা আর আপসের হিসাব।

প্র ০৩বাজারঘরের scale দাম float-এ না রেখে পয়সায় পূর্ণসংখ্যা হিসেবে রাখে। এটি কি অতিরিক্ত সতর্কতা, নাকি সত্যিই দরকার?

অংশ ৪-এর C program-এ উত্তর আছে: 150 g আলুর দাম গাণিতিকভাবে 9.825 টাকা, নিয়মে গোল করলে 9.83, কিন্তু double-এ হিসাব করে %.2f ছাপলে 9.82. কারণ দশমিক 9.825 binary ভগ্নাংশে হুবহু লেখা যায় না, যেমন দশমিকে ১/৩ হুবহু লেখা যায় না। সবচেয়ে কাছের binary মানটি একটু কম, তাই “অর্ধেক” অবস্থাটি আর অর্ধেক থাকে না।

দোকানের হিসাবে এর মানে স্পষ্ট। দাঁড়িপাল্লা যে দাম দেখায়, ক্যাশ রেজিস্টার আর দিনের শেষের খাতার সঙ্গে তা মিলতে হয়। দুই যন্ত্র দুই পদ্ধতিতে হিসাব করলে মাঝে মাঝে এক পয়সার অমিল হবে, আর কোনটি ঠিক তা নিয়ে বিতর্ক উঠবে। পূর্ণসংখ্যার হিসাব নিশ্চিত: একই input-এ সব যন্ত্রে, সব compiler-এ, সব optimization স্তরে একই ফল।

Embedded দিক থেকে আরও কারণ আছে। ARM Cortex-M3-এ floating-point unit নেই (Cortex-M4-এ একটি single-precision FPU ঐচ্ছিকভাবে থাকতে পারে), তাই float-এর প্রতিটি গুণ-ভাগ software library-তে অনেকগুলো নির্দেশে হয়: ধীর, আর program-এর আকার বাড়ে। ছোট 8-বিট MCU-তে এই খরচ আরও বেশি। আর গোল করার নিয়মটি পূর্ণসংখ্যায় নিজে লিখতে হয় (+ 500), তাই নিয়মটি কোডে স্পষ্ট থাকে, লুকানো থাকে না।

তবে পূর্ণসংখ্যারও ফাঁদ আছে: overflow. net_g × 6550 ৩২-বিটে সর্বোচ্চ প্রায় ২১৪ কোটি পর্যন্ত ধরে; 5000 g-এ গুণফল 3 কোটি 27 লাখ 50 হাজার, নিরাপদ। কিন্তু কেউ যদি দাম মিলিপয়সায় বা ওজন মিলিগ্রামে রাখতে চান, সীমা দ্রুত পেরিয়ে যেতে পারে। তাই fixed-point নকশায় প্রতিটি গুণফলের সর্বোচ্চ মান হিসাব করে রাখতে হয়। পর্ব ৪০-এ (Fixed-point গণিত) Q format আর এই হিসাব বিস্তারিত।

মূল উপলব্ধি: টাকা-পয়সা, মিটার রিডিং বা যেকোনো হিসাব যা মানুষ মিলিয়ে দেখবে, তা নির্দিষ্ট এককে পূর্ণসংখ্যায় রাখুন; গোল করার নিয়ম কোডে স্পষ্ট লিখুন, আর overflow-এর সীমা হিসাব করুন।

প্র ০৪আসল board ছাড়া কি embedded system শেখা সম্ভব? Simulator কোথায় সত্যি বলে, আর কোথায় চুপ থাকে?

পেশাদার জগতে firmware-এর বড় অংশ আজ আসল hardware আসার আগেই লেখা আর পরীক্ষা করা হয়। নতুন chip বা নতুন board তৈরি হতে মাস লাগে; সেই সময়ে দল simulator, emulator আর host-এ চলা unit test দিয়ে কাজ এগিয়ে রাখে। Renode বা QEMU-র মতো open-source tool, আর chip নির্মাতাদের নিজস্ব simulator, এই কাজেই ব্যবহার হয়। তাই simulator দিয়ে শেখা “খেলনা” নয়, বাস্তব কাজের একটি অংশ।

Simulator-এর শক্তি তিনটি। নির্ভুল পুনরাবৃত্তি: একই input-এ প্রতিবার একই ফল, তাই bug ধরা আর মেলানো সহজ; এই পর্বের scale-এর run প্রতিবার হুবহু একই লাইন দেয়। দৃশ্যমানতা: প্রতিটি register, প্রতিটি flag, প্রতিটি T-state দেখা যায়, যা আসল chip-এ debugger ছাড়া দেখা যায় না। নিরাপত্তা: ভুল firmware কিছু পোড়ায় না, battery ফোলায় না।

কিন্তু simulator তা-ই দেখায়, যা তার নকশায় রাখা হয়েছে। কোর্সের board-এ প্রতিটি নির্দেশ ১টি cycle (Spec decision 17), UART-এর পাঠানো তাৎক্ষণিক (Spec decision 24), ADC-র conversion তাৎক্ষণিক আর noise ঐচ্ছিক (Spec decision 25). আসল জগতে আছে বৈদ্যুতিক noise, button-এর লাফালাফি, voltage কমে যাওয়া (brown-out), তাপে sensor-এর মান সরে যাওয়া, তারের দৈর্ঘ্যে সংকেত বিকৃত হওয়া। এগুলো simulator নিজে থেকে দেখায় না; ইচ্ছে করে model করতে হয়।

তাই বাস্তব পদ্ধতি স্তরে স্তরে: আগে host-এ যুক্তি পরীক্ষা (Python বা C-তে, যেমন এই পর্বের scale আর cold room-এর কোড), তারপর simulator-এ পুরো firmware, তারপর আসল board, আর শেষে hardware-in-the-loop (HIL) test, যেখানে আসল board-কে একটি কম্পিউটার নকল sensor-সংকেত দেয়। এই ধাপগুলো পর্ব ৬৪-এ (এমবেডেড software testing), আর আসল board-এর debugging-এর tool (JTAG, SWD, logic analyzer) পর্ব ৩৮-এ। হাতে Arduino বা STM32-এর কোনো board থাকলে কোর্সের firmware সেখানে চালানোর পথও সেখানে আলোচনা হবে।

মূল উপলব্ধি: Simulator যুক্তি আর সময়ের মডেল যাচাই করে; আসল hardware বাস্তব জগতের গোলমাল যাচাই করে। দুটিই লাগে, আর কোনটি কী যাচাই করেছে তা জানা দরকার।

প্র ০৫বাজারঘরের scale শুধু ওজন পাঠায়। তার নিরাপত্তা নিয়ে কোর্সের শুরুতেই ভাবতে হবে কেন?

কারণ IoT device-এর নিরাপত্তার ভুল শুধু সেই device-এর ক্ষতি করে না। ২০১৬ সালের Mirai botnet এর সবচেয়ে পরিচিত উদাহরণ। Mirai নামের ক্ষতিকর software ইন্টারনেটে খোলা IP ক্যামেরা আর ভিডিও রেকর্ডারের মতো যন্ত্র খুঁজত, আর কারখানার ডিফল্ট username-password-এর একটি ছোট তালিকা দিয়ে ঢোকার চেষ্টা করত। কয়েক লক্ষ যন্ত্র দখলে নিয়ে সেগুলো দিয়ে খুব বড় DDoS আক্রমণ চালানো হয়, যার একটি ২০১৬ সালের অক্টোবরে Dyn নামের DNS সেবায় আঘাত করে অনেক বড় ওয়েবসাইট সাময়িকভাবে ব্যবহারকারীদের নাগালের বাইরে নিয়ে যায়। যন্ত্রগুলোর মালিকেরা অনেকে টেরই পাননি।

শিক্ষাটি নকশার: এই যন্ত্রগুলোর দুর্বলতা জটিল কিছু ছিল না। সবার এক ডিফল্ট password, অপ্রয়োজনীয় খোলা সেবা, আর update-এর ব্যবস্থা না থাকা। এগুলো নকশার শুরুতেই ঠিক করার বিষয়, পরে জোড়াতালি দেওয়ার নয়। বাজারঘরের scale-এ ভাবুন: কেউ যদি network থেকে দর 65.50 থেকে বদলে দিতে পারে, বা নকল firmware বসাতে পারে, তাহলে প্রতিটি বিক্রির হিসাব ভুল হবে। Cold room-এর alarm বন্ধ করে দিলে মাছ নষ্ট হবে।

প্রতিরক্ষার মৌলিক নিয়মগুলো এই কোর্সে ধাপে ধাপে আসবে: প্রতিটি device-এর আলাদা পরিচয় আর গোপন key, কোডে কোনো আসল password না রাখা, broker-এর সঙ্গে TLS দিয়ে এনক্রিপ্ট করা সংযোগ, শুধু signature-যাচাই করা firmware update (secure boot আর OTA, পর্ব ৭৭), আর অপ্রয়োজনীয় সেবা বন্ধ রাখা। পর্ব ৭৬-এ বাজারঘরের device-এর threat model তৈরি হবে। Cybersecurity কোর্সের পর্ব ৩৫-এ mobile আর IoT নিরাপত্তার বৃহত্তর ছবি আছে।

এই পর্বের MQTT demo-তে broker-এ কোনো password নেই, আর সেটি ইচ্ছাকৃত: এটি শুধু নিজের কম্পিউটারের ভেতরে (127.0.0.1) চলে, শেখার জন্য। একই নকশা ইন্টারনেটে খোলা অবস্থায় রাখলে সেটিই হতো Mirai-যুগের ভুল।

মূল উপলব্ধি: IoT-তে নিরাপত্তা একটি বৈশিষ্ট্য নয়, নকশার শর্ত। প্রথম দিন থেকে প্রশ্ন রাখুন: কে এই device-এ কথা বলতে পারে, আর কীভাবে আমি নিশ্চিত হব যে firmware আমারই?

অনুশীলন

প্রথমটিতে একটি firmware function লিখবেন; বাকিগুলোতে ভুল খোঁজা, আউটপুট অনুমান আর হাতে হিসাব।

  1. দামের function লিখুন (বাস্তবায়ন): বাজারঘর এখন পেঁয়াজও বিক্রি করবে, দর 42.00 টাকা/kg. C-তে একটি function লিখুন int32_t price_paisa(int32_t net_g, int32_t rate_paisa_per_kg), যা দর parameter হিসেবে নেয়, float ব্যবহার করে না, অর্ধেক হলে ওপরে গোল করে, ওজন 0 বা ঋণাত্মক হলে 0 দেয়, আর 5000 g-এর বেশি হলে −1 (overload) ফেরত দেয়। এই input-গুলোতে ফল কী হবে: (150, 6550), (1250, 6550), (500, 6550), (800, 4200), (5001, 6550), (−20, 6550)?
    #define CAPACITY_G 5000
    int32_t price_paisa(int32_t net_g, int32_t rate_paisa_per_kg)
    {
        if (net_g > CAPACITY_G)
            return -1;
        if (net_g <= 0)
            return 0;
        return (net_g * rate_paisa_per_kg + 500) / 1000;   /* round half up */
    }

    ক্রম গুরুত্বপূর্ণ: আগে overload যাচাই, তারপর শূন্য বা ঋণাত্মক, তারপর হিসাব। ল্যাবে Clang 22.1.8 (-Wall -Wextra, কোনো warning নেই) দিয়ে চালানো আসল ফল: 983, 8188, 3275, 3360, -1, 0. পেঁয়াজের হিসাব: 800 × 4200 = 3360000, + 500 = 3360500, ÷ 1000 = 3360 পয়সা = 33.60 টাকা. ঋণাত্মক ওজন বাস্তবে আসতে পারে: tare-এর পরে পাত্র সরিয়ে নিলে net ঋণাত্মক হয়; তখন দাম 0. আর −1 দিয়ে overload জানানো একটি সাধারণ C-রীতি, তবে ডাকার জায়গায় এটি যাচাই করতে ভুললে −0.01 টাকা ছাপা হতে পারে; বড় firmware-এ আলাদা status ফেরত দেওয়া বেশি নিরাপদ।

  2. ভুলটি খুঁজুন (assembly): একজন AI assistant এই 8085 program দিয়ে বলেছে, “এটি 49H আর 56H যোগ করে 2052H-এ রাখে, মোট ২৮টি T-state”. দুটি ভুল খুঁজে বের করুন।
            ORG 2000H
    START:  MVI A,49H
            ADD 56H
            STA 2052H
            HLT

    ভুল ১ (নির্দেশ): 8085-এর ADD শুধু একটি register বা মেমরি (ADD B, ADD M) নেয়; একটি সরাসরি সংখ্যা যোগ করার নির্দেশ ADI. কোর্সের assembler এটি চালানোর আগেই আটকায় (সত্যিকারের run):

    $ python -B sim8085.py asm ai_wrong.asm
    assembly error: line 3: bad operand 56H for ADD
        ADD 56H

    ভুল ২ (সময়): সঠিক program-এ (ADI 56H) মোট T-state 7 + 7 + 13 + 5 = 32, ২৮ নয়। সম্ভবত AI STA-কে ৯ ধরেছে, বা HLT-কে ১ ধরেছে। শিক্ষা: assembly-র দাবি assembler-এ, আর সময়ের দাবি Intel-এর টেবিল বা simulator-এ যাচাই করুন। ADD/ADI-এর মতো register বনাম immediate-এর জোড়া (SUB/SUI, ANA/ANI, CMP/CPI) পর্ব ০৯ আর ১০-এ।

  3. আউটপুট অনুমান করুন: চার নির্দেশের program-এ শুধু দুটি সংখ্যা বদলানো হলো: MVI A,0F0H, ADI 20H, STA 2052H, HLT. শেষে A, [2052H], S Z AC P CY, পুরো flag byte (F) আর মোট সময় (3 MHz) কত হবে?

    F0H + 20H = 110H, যা ৮ বিটে আঁটে না: A-তে থাকে 10H, আর বাড়তি 1 যায় CY-তে। তাই A = 10H, [2052H] = 10H. Flag: S = 0 (10H = 00010000b, বাঁয়ের বিট 0), Z = 0, AC = 0 (নিচের nibble 0 + 0), P = 0 (একটি মাত্র 1, বিজোড়), CY = 1. Flag byte-এ শুধু CY (বিট 0), তাই F = 01H. সময় আগের মতোই: নির্দেশ একই, শুধু data আলাদা, তাই 32 T = 10.67 µs. Simulator-এর আসল run:

    A=10 B=00 C=00 D=00 E=00 H=00 L=00 SP=0000 PC=2008
    Flags: S=0 Z=0 AC=0 P=0 CY=1   (F=01H)
    Memory 2052H..2052H:
      2052H: 10
    Instructions: 4   T-states: 32

    শিক্ষা: data বদলালে নির্দেশের সময় বদলায় না (এখানে কোনো শর্তযুক্ত jump নেই)। Carry আর overflow-এর পার্থক্য পর্ব ০৫-এ।

  4. হাতে হিসাব (smart scale): খালি scale-এ (tare 0) পরপর রাখা হলো 800 g, 5000 g আর 5001 g আলু। প্রতিটির জন্য ADC raw (board-এর model: raw = 400 + 0.7 × grams, পূর্ণসংখ্যায় গোল), gross ওজন আর দাম (65.50 টাকা/kg) হিসাব করুন। কোনটি overload?

    800 g: raw = 400 + 560 = 960; gross = (960 − 400) × 2000 ÷ 1400 = 1120000 ÷ 1400 = 800 g; দাম (800 × 6550 + 500) ÷ 1000 = 5240500 ÷ 1000 = 5240 পয়সা = 52.40 টাকা.

    5000 g: raw = 400 + 3500 = 3900; gross = 3500 × 2000 ÷ 1400 = 5000 g. নিয়ম “5000-এর বেশি হলে overload”, আর 5000 বেশি নয়, তাই দাম (5000 × 6550 + 500) ÷ 1000 = 32750 পয়সা = 327.50 টাকা.

    5001 g: 400 + 3500.7 = 3900.7, গোল করে raw = 3901; gross = 3501 × 2000 ÷ 1400 = 5001.43, গোল করে 5001 g > 5000, তাই overload. Virtual board-এ আসল scale.c firmware এই তিন ভারে চালানো হয়েছে (সত্যিকারের run, নিজের script দিয়ে):

    [   200.0999 ms] UART: raw=960 gross=800 g tare=0 g net=800 g price=52.40 Tk
    [   400.1104 ms] UART: raw=3900 gross=5000 g tare=0 g net=5000 g price=327.50 Tk
    [   600.0529 ms] UART: OVERLOAD: gross=5001 g > 5000 g

    সীমার ঠিক ওপরে আর নিচে (5000 আর 5001) পরীক্ষা করার এই অভ্যাসের নাম boundary testing; firmware-এর সবচেয়ে বেশি bug লুকিয়ে থাকে সীমায়, > আর >=-এর পার্থক্যে।

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

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

ক্রমএকটি digital smart scale-এ ওজন থেকে দাম পাঠানো পর্যন্ত ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. ⚖️ Load cell-এ ভার পড়ে, ছোট voltage তৈরি হয়
  2. 🔊 Amplifier সংকেত বড় করে
  3. 🔢 ADC voltage-কে count-এ বদলায়
  4. 📐 Firmware calibration দিয়ে count থেকে গ্রাম বের করে
  5. 💰 Tare বাদ দিয়ে net ওজন আর পয়সায় দাম হিসাব
  6. 📡 Display-তে দেখানো আর MQTT-তে publish

Intel 8085-এ MVI A,49H নির্দেশে কয়টি machine cycle আর কয়টি T-state লাগে?

  • ১টি machine cycle, ৪টি T-state
  • ৩টি machine cycle, ১০টি T-state
  • ২টি machine cycle, ৭টি T-state
  • ২টি machine cycle, ২টি T-state

একটি 8085 program-এ মোট ৩২টি T-state লাগে। CPU clock 3 MHz (6 MHz crystal) হলে program চলতে কত সময় লাগে?

  • প্রায় 10.67 µs
  • প্রায় 5.33 µs
  • 32 µs
  • 96 µs

8085-এ A = 49H থাকা অবস্থায় ADI 56H চলল। এরপর S, Z আর CY flag কী হবে?

  • S = 0, Z = 0, CY = 1
  • S = 1, Z = 0, CY = 0
  • S = 1, Z = 1, CY = 0
  • কোনো flag বদলায় না

কোন বর্ণনাটি একটি microcontroller-এর সঙ্গে সবচেয়ে ভালো মেলে?

  • একটি chip-এ শুধু CPU; মেমরি আর I/O-র জন্য আলাদা chip লাগে
  • সবচেয়ে দ্রুত গতির জন্য নকশা করা বড় CPU, server-এ ব্যবহার হয়
  • যেকোনো chip, যাতে একটি operating system চলে
  • CPU, flash, RAM আর timer-ADC-UART একই chip-এ, নির্দিষ্ট কাজের জন্য

একটি scale-এর calibration: খালি অবস্থায় ADC = 400 count, 2000 g-এ 1800 count. ADC 1380 count দেখালে ওজন কত (সরলরেখা ধরে)?

  • 1380 g
  • 980 g
  • 1400 g
  • প্রায় 1533 g

দর 65.50 টাকা/kg = 6550 পয়সা/kg, আর দাম = (net_g × 6550 + 500) ÷ 1000 পয়সা (পূর্ণসংখ্যার ভাগ)। 150 g-এর দাম কত?

  • 982 পয়সা (9.82 টাকা)
  • 983 পয়সা (9.83 টাকা)
  • 9825 পয়সা (98.25 টাকা)
  • 6550 পয়সা (65.50 টাকা)

শব্দকোষ

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

মনে রাখুন

  1. Microprocessor = chip-এ শুধু CPU; microcontroller = CPU, মেমরি আর peripheral এক chip-এ; IoT = network-এ যুক্ত embedded যন্ত্র।
  2. প্রতিটি নির্দেশ fetch → decode → execute; 8085-এ MVI A,49H = ২টি machine cycle, ৭টি T-state; 3 MHz-এ এক T-state ≈ 0.333 µs.
  3. চার নির্দেশের program 49H + 56H = 9FH রাখে 2052H-এ, ৩২টি T-state ≈ 10.67 µs, flag F = 84H.
  4. বাজারঘরের সংখ্যা: 400 আর 1800 count-এ calibration, 65.50 টাকা/kg, 1250 g → 81.88 টাকা; cold room 0.00–8.00 °C, তিনবার নিশ্চিত, 0.50 °C hysteresis.
  5. পথ বেছে নিন (মেকার, বিশ্ববিদ্যালয়, চাকরি ও ইন্টারভিউ); প্রতিটি দাবি simulator, datasheet আর হাতের হিসাবে যাচাই করুন, AI-এর উত্তরও।

পরের পর্বে: ১৯৭১ সালের ৪-বিটের 4004 থেকে 8085, Z80, 8086 আর IBM PC, তারপর ARM, 8051, AVR, Cortex-M, ESP32 আর RISC-V microcontroller: কোন chip কোন সমস্যার সমাধান করতে এসেছিল, আর 8085/8086 কেন এখনো পরীক্ষায় আসে।

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

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