Power, energy আর embedded সিস্টেম — microcontroller থেকে SoC

১ · Power আর energy — watt, joule আর ব্যাটারির mAh

এ পর্যন্ত এই কোর্সে আমরা প্রায় সবসময় একটি প্রশ্ন করেছি: কত দ্রুত? পর্ব ০৩-এ (পারফরম্যান্স মাপা) CPU time, CPI আর Amdahl. কিন্তু আজকের বেশিরভাগ কম্পিউটার — ফোন, ঘড়ি, রাউটার, মোটরসাইকেলের ECU, মাঠে বসানো sensor — আরেকটি প্রশ্নে বাঁধা: কত বিদ্যুৎ খরচ হবে, আর তাপ কোথায় যাবে? Data center-এও বিদ্যুৎ বিল আর ঠান্ডা রাখার খরচ বড় হিসাব। পর্ব ০২-এ (ইতিহাস আর প্রবণতা) দেখেছেন, ২০০৫ সালের আশেপাশে power wall-এর কারণেই clock বাড়া থেমেছিল। এই পর্বে সেই ইতিহাস আর না বলে আমরা হিসাবের হাতিয়ার হাতে নেব।

প্রথমে দুটি শব্দ আলাদা করা জরুরি, কারণ এখানেই সবচেয়ে বেশি গোলমাল হয়।

• Power (ক্ষমতা): প্রতি সেকেন্ডে কতটা শক্তি খরচ হচ্ছে। একক watt (W). Chip কতটা গরম হবে, power supply আর পাখা কত বড় লাগবে — power ঠিক করে।
• Energy (শক্তি): মোট কতটা শক্তি খরচ হলো। একক joule (J); ১ J = ১ W × ১ সেকেন্ড। ব্যাটারি কতক্ষণ চলবে, বিদ্যুৎ বিল কত আসবে — energy ঠিক করে।

ব্যাটারির গায়ে লেখা mAh আসলে কী

ব্যাটারির গায়ে সাধারণত লেখা থাকে mAh (milliampere-hour) — কত current কত ঘণ্টা দিতে পারবে। কিন্তু mAh একা energy নয়; voltage দিয়ে গুণ করলে তবে energy. তাই দুটি ভিন্ন voltage-এর ব্যাটারির mAh সরাসরি তুলনা করা যায় না। ব্যাটারির ধারণক্ষমতা:

• ফোন: ৫০০০ mAh, nominal ৩.৮৫ V (ধরা যাক) → ৫০০০ × ৩.৮৫ ÷ ১০০০ = ১৯.২৫ Wh = ১৯.২৫ × ৩৬০০ = ৬৯,৩০০ J. ফোন গড়ে ১.৫ W খরচ করলে আয়ু ≈ ১৯.২৫ ÷ ১.৫ ≈ ১২.৮ ঘণ্টা।
• Power bank: গায়ে “১০০০০ mAh” — কিন্তু এটি ভেতরের ৩.৭ V cell-এর হিসাব: ৩৭ Wh. USB-তে ৫ V দিতে গিয়ে রূপান্তরে কিছু শক্তি তাপ হয়; দক্ষতা ৮৫% ধরলে বাইরে আসে ৩১.৪৫ Wh, যা ৫ V-এ মাত্র ৩১.৪৫ ÷ ৫ ≈ ৬২৯০ mAh. তাই ১৯.২৫ Wh-এর ফোন প্রায় ৩১.৪৫ ÷ ১৯.২৫ ≈ ১.৬ বার ভরা যায় (ফোনের charging-এর ক্ষতি ধরলে আরও কম), দুবার নয়।

২ · Dynamic power আর static power — chip কোথায় বিদ্যুৎ খায়

পর্ব ০৮-এ (Logic gate আর transistor) দেখেছেন, CMOS gate-এর output উল্টালে তার পেছনের ছোট capacitance charge বা discharge হয়। সেই খরচটিই dynamic power:

এখানে C = chip-এর মোট switching capacitance, V = supply voltage, f = clock frequency, আর α = activity factor — প্রতি cycle-এ গড়ে কোন ভগ্নাংশ capacitance আসলে উল্টায়। Idle থাকা ALU-র α প্রায় শূন্য, ভারী গুণের loop-এ বেশি। Clock-এর তার নিজে প্রতি cycle-এ দুবার উল্টায়, তাই clock network-এর α সবচেয়ে বেশি — এ কারণেই chip-এর power-এর বড় একটি অংশ শুধু clock বিতরণে যায় বলে ধরা হয় (নকশাভেদে ভিন্ন)।

হাতে-কলমে: V আর f দুটিই ১৫% কমালে

α = ০.১৫, C = ২০ nF, V = ১.০ V, f = ২ GHz হলে P = 0.15 × 20×10⁻⁹ × 1.0² × 2×10⁹ = ৬ W. এখন V = ০.৮৫ V, f = ১.৭ GHz:

1. V² অনুপাত = ০.৮৫² = ০.৭২২৫
2. f অনুপাত = ০.৮৫
3. মোট = ০.৭২২৫ × ০.৮৫ = ০.৮৫³ = ০.৬১৪১ → P ≈ ৬ × ০.৬১৪১ ≈ ৩.৬৮ W — প্রায় ৩৯% কম, অথচ গতি কমেছে মাত্র ১৫% হারে।

আরও একটি সূক্ষ্ম কথা: একটি নির্দিষ্ট কাজের cycle সংখ্যা একই থাকলে energy প্রতি কাজে কমে শুধু V²-এর অনুপাতে (০.৭২২৫), কারণ f কমলে সময় বাড়ে আর দুটি কাটাকাটি হয়। অর্থাৎ শুধু f কমালে (V একই রেখে) power কমে, কিন্তু কাজপ্রতি dynamic energy একটুও কমে না — উল্টো leakage-এর সময় বাড়ে। এটিই অংশ ৪-এর মূল শিক্ষা।

Static power — বন্ধ থেকেও খরচ

বন্ধ transistor-ও পুরোপুরি বন্ধ নয় — সামান্য current চুইয়ে যায়: leakage. এর power মোটামুটি P_static ≈ V × I_leak, আর এটি clock চলুক বা না চলুক, circuit-এ voltage থাকলেই খরচ হয়। কেন ছোট transistor-এ এটি বেড়েছে? Voltage কমাতে গিয়ে threshold voltage-ও কমাতে হয়েছিল (পর্ব ০২), আর subthreshold leakage threshold কমার সাথে প্রায় সূচকীয়ভাবে বাড়ে; খুব পাতলা gate oxide-এর ভেতর দিয়েও current চুইয়ে যায়। ২০০০-এর দশকের মাঝামাঝি কিছু process-এ leakage মোট power-এর উল্লেখযোগ্য অংশ হয়ে উঠেছিল বলে ব্যাপকভাবে বর্ণিত; পরে high-k gate আর FinFET-এর মতো কাঠামো এটি অনেকটা, তবে পুরোপুরি নয়, সামলেছে। গরম chip আরও বেশি leak করে।

৩ · প্রতিটি কাজের energy — হিসাব সস্তা, ডেটা আনা-নেওয়া দামি

Power-এর বদলে প্রতিটি operation-এর energy ভাবলে একটি চমকপ্রদ ছবি পাওয়া যায়। Stanford-এর Mark Horowitz ২০১৪ সালে ISSCC সম্মেলনে “Computing's energy problem” নামে একটি বক্তৃতায় প্রায় ৪৫ nm প্রযুক্তির জন্য অনুমিত সংখ্যার একটি টেবিল দেখান, যা পরে বহু বইয়ে আর বক্তৃতায় উদ্ধৃত হয়েছে। নিচের মানগুলো সেই ধরনের টেবিলের মোটামুটি মাত্রা (order of magnitude) — নির্দিষ্ট chip বা আজকের process-এ সংখ্যা ভিন্ন, কিন্তু অনুপাতের গল্প মোটামুটি একই থাকে বলে ধরা হয়।

শিক্ষা পরিষ্কার: একটি যোগের চেয়ে তার সংখ্যাটি DRAM থেকে আনতে হাজার হাজার গুণ বেশি energy লাগে। তাই cache (পর্ব ৪৪, মেমরি হায়ারার্কি) energy-ও বাঁচায়, আর GPU ও AI accelerator (পর্ব ৫৫, GPU আর AI accelerator) একবার আনা ডেটা বহুবার ব্যবহারের জন্য নকশা করা। সাধারণ CPU core-এ instruction আনা, decode আর register file পড়ার “প্রশাসনিক” খরচও আসল যোগের চেয়ে অনেক বেশি।

৪ · DVFS — voltage-frequency-র জোড়া, race-to-idle বনাম ধীরে-সুস্থে

পর্ব ১৮-এ (Timing আর clock) দেখেছেন, clock-এর period critical path-এর delay-র চেয়ে বড় হতে হয়। আর transistor-এর গতি voltage-এর ওপর নির্ভর করে — voltage কমালে gate ধীর হয়। তাই voltage আর frequency স্বাধীন নয়: প্রতিটি frequency-র জন্য একটি সর্বনিম্ন নিরাপদ voltage আছে। DVFS (dynamic voltage and frequency scaling) মানে চলার সময়ে কাজের চাপ বুঝে এই জোড়া বদলানো। প্রতিটি অনুমোদিত জোড়াকে ACPI-র ভাষায় বলে P-state: P0 সবচেয়ে দ্রুত (সবচেয়ে বেশি voltage), P1, P2 … ক্রমে ধীর আর কম voltage.

কে বদলায়? সাধারণত OS-এর একটি “governor” কাজের চাপ (utilization) দেখে সিদ্ধান্ত নেয়, আর chip-এর power-management firmware বা hardware নিরাপদে voltage regulator আর clock বদলায়। আধুনিক অনেক CPU-তে hardware নিজেই আরও দ্রুত এই সিদ্ধান্ত নেয় (নাম আর খুঁটিনাটি নির্মাতাভেদে)। Software-এর দিক, governor আর Android-এর নীতি OS কোর্সের ব্যাটারির হিসাব — DVFS, governor, big.LITTLE অংশে আছে।

নিচের stepper-এ একটি core-এর কয়েকটি মুহূর্ত। Dynamic power পূর্ণ চাপে হিসাব করা, αC = ৩ nF ধরে (অনুমিত মান):

1t = 0 ms   : ভিডিও export, load 95%2t = 40 ms  : export শেষ, browsing, load 40%3t = 80 ms  : শুধু গান চলছে, load 10%4t = 120 ms : স্ক্রিন বন্ধ, কোনো কাজ নেই5t = 160 ms : notification, হঠাৎ কাজ

Race-to-idle বনাম ধীরে-সুস্থে — energy-র তুলনা

একটি কাজে ২×10⁹ cycle লাগে, আর ২ সেকেন্ডের মধ্যে শেষ করতে হবে। দুটি পথ: (ক) race-to-idle — ২ GHz-এ ১ সেকেন্ডে শেষ করে বাকি ১ সেকেন্ড গভীর ঘুম; (খ) ধীরে-সুস্থে — ১ GHz-এ পুরো ২ সেকেন্ড, তবে কম voltage-এ। কোনটি কম energy খরচ করে? উত্তর নির্ভর করে অনুমানের ওপর, তাই নিচের calculator অনুমানগুলো স্পষ্ট লিখে হিসাব করে: αC = ৩ nF, leakage voltage-এর সমানুপাতিক (সরলীকরণ), ঘুমের power ০.০৫ W.

// Dynamic power + DVFS energy: race-to-idle vs slow-and-steady. ALL values are ASSUMED teaching numbers.
const dyn = (a, C, V, f) => a * C * V * V * f;          // P_dyn = alpha * C * V^2 * f  (watts)
const a = 0.15, C = 20e-9;                                // activity factor, switched capacitance (F)
const p0 = dyn(a, C, 1.0, 2e9), p1 = dyn(a, C, 0.85, 1.7e9);
console.log(`P_dyn at 1.00 V, 2.0 GHz = ${p0.toFixed(3)} W`);
console.log(`P_dyn at 0.85 V, 1.7 GHz = ${p1.toFixed(3)} W  (x${(p1 / p0).toFixed(4)})`);
// A job of 2e9 cycles must finish inside a 2 s window. Leakage ~ proportional to V (assumed).
const cycles = 2e9, win = 2, aC = 3e-9, idleW = 0.05;     // aC = alpha*C; idle = deep sleep power
const plan = (name, V, f, leakAt1V) => {
  const t = cycles / f, pd = aC * V * V * f, ps = leakAt1V * V;
  const eRun = (pd + ps) * t, eIdle = idleW * (win - t);
  return { name, V, f, t, pd, ps, eRun, eIdle, E: eRun + eIdle };
};
for (const leak of [1.0, 3.0]) {
  console.log(`\nleakage = ${leak} W at 1.0 V, idle (sleep) = ${idleW} W, window = ${win} s`);
  console.log("plan                 V     f(GHz)  t(s)  Pdyn(W) Pstat(W)  E_run  E_idle  E_total(J)");
  for (const p of [plan("race (fast, sleep)", 1.0, 2e9, leak),
                   plan("pace (slow, low V)", 0.75, 1e9, leak),
                   plan("slow, V stuck 1.0", 1.0, 1e9, leak)]) {
    console.log(p.name.padEnd(19) + p.V.toFixed(2).padStart(6) + (p.f / 1e9).toFixed(1).padStart(8) +
      p.t.toFixed(1).padStart(6) + p.pd.toFixed(3).padStart(9) + p.ps.toFixed(2).padStart(9) +
      p.eRun.toFixed(3).padStart(7) + p.eIdle.toFixed(3).padStart(8) + p.E.toFixed(3).padStart(12));
  }
}

P_dyn at 1.00 V, 2.0 GHz = 6.000 W
P_dyn at 0.85 V, 1.7 GHz = 3.685 W  (x0.6141)

leakage = 1 W at 1.0 V, idle (sleep) = 0.05 W, window = 2 s
plan                 V     f(GHz)  t(s)  Pdyn(W) Pstat(W)  E_run  E_idle  E_total(J)
race (fast, sleep)   1.00     2.0   1.0    6.000     1.00  7.000   0.050       7.050
pace (slow, low V)   0.75     1.0   2.0    1.687     0.75  4.875   0.000       4.875
slow, V stuck 1.0    1.00     1.0   2.0    3.000     1.00  8.000   0.000       8.000

leakage = 3 W at 1.0 V, idle (sleep) = 0.05 W, window = 2 s
plan                 V     f(GHz)  t(s)  Pdyn(W) Pstat(W)  E_run  E_idle  E_total(J)
race (fast, sleep)   1.00     2.0   1.0    6.000     3.00  9.000   0.050       9.050
pace (slow, low V)   0.75     1.0   2.0    1.687     2.25  7.875   0.000       7.875
slow, V stuck 1.0    1.00     1.0   2.0    3.000     3.00 12.000   0.000      12.000

৫ · Gating, ঘুম, তাপ আর ভিন্ন-স্বভাবের core — আর energy মাপার মাপকাঠি

Clock gating আর power gating

C-state — ঘুমের বিভিন্ন গভীরতা

কাজ না থাকলে core ঘুমায়, আর ঘুমেরও স্তর আছে — x86/ACPI-র ভাষায় C-state. C0 মানে জেগে কাজ করছে; C1-এ instruction চালানো থামে আর clock gated (RISC-V-এ এর কাছাকাছি কাজ করে wfi — “wait for interrupt” instruction, ARM-এও WFI); আরও গভীর অবস্থায় (নাম আর সংখ্যা chip-ভেদে, যেমন C6) core-এর voltage কাটা হয় আর তার আগে নিজস্ব cache-এর dirty ডেটা নিচের স্তরে লিখে দেওয়া হয়। নিয়ম মোটামুটি সর্বজনীন: যত গভীর ঘুম, তত কম power, কিন্তু তত বেশি জাগার সময় আর ঢোকা-বেরোনোর energy. তাই খুব অল্প সময়ের বিরতিতে গভীর ঘুম লোকসান — OS-এর idle governor আন্দাজ করে, পরের interrupt কত দূরে।

তাপ, TDP আর dark silicon

Chip-এর সব power শেষ পর্যন্ত তাপ। TDP (thermal design power) মোটামুটি বলে, chip-কে ঠান্ডা রাখার ব্যবস্থা (heatsink, পাখা) দীর্ঘ সময় ধরে কত W তাপ সরাতে পারার মতো করে নকশা করতে হবে। এটি সর্বোচ্চ power নয়: অনেক chip অল্প সময় TDP-র ওপরে “boost” করে, আর নির্মাতাভেদে সংজ্ঞাও পুরো এক নয়। তাপমাত্রা সীমা ছুঁলে hardware নিজেই frequency কমায় — thermal throttling; গরমের দিনে ফোনে গেম ধীর হওয়ার এটি একটি সম্ভাব্য কারণ। এই তাপ-সীমার জন্যই সব transistor একসাথে পূর্ণ গতিতে চালানো যায় না — পর্ব ০২-এর dark silicon.

ভিন্ন-স্বভাবের core — big.LITTLE আর P+E

একটি বড় out-of-order core (পর্ব ৪০) প্রতি instruction-এ অনেক বেশি energy খরচ করে — বড় instruction window, বেশি port, বেশি অনুমানভিত্তিক কাজ। ছোট in-order core ধীর, কিন্তু প্রতি কাজে অনেক কম energy নেয়। Heterogeneous core-এর ধারণা: একই chip-এ দুই ধরনের core, আর OS কাজ বুঝে বসায়। ARM ২০১১ সালে এর নাম দেয় big.LITTLE; প্রায় সব আধুনিক ফোনের SoC-তে এমন মিশ্রণ আছে, আর ২০২১ সালের দিকে Intel-এর ডেস্কটপ-ল্যাপটপ chip-এও “P-core” (performance) আর “E-core” (efficiency) এসেছে। ছোট কাজ (notification, পেছনের sync) ছোট core-এ, ভারী কাজ বড় core-এ।

Energy-এর মাপকাঠি — perf/W আর EDP

দুটি নকশা তুলনা করতে কয়েকটি মাপকাঠি চলে:

• Perf/W: প্রতি watt-এ গতি = (কাজ/সেকেন্ড) ÷ W = কাজ প্রতি joule — অর্থাৎ প্রতি কাজের energy-র উল্টো।
• EDP (energy-delay product): E × D. শুধু energy দেখলে খুব ধীর নকশাও “ভালো” মনে হতে পারে; EDP গতিকেও সমান গুরুত্ব দেয়। কম EDP ভালো। গতিকে আরও গুরুত্ব দিতে ED²P = E × D².

উদাহরণ: একটি কাজ বড় core-এ ৪ W-এ ১ সেকেন্ড, ছোট core-এ ১ W-এ ৩ সেকেন্ড।

শুধু energy বা perf/W দেখলে ছোট core জেতে (৩ J < ৪ J); EDP বা ED²P দেখলে বড় core অনেক এগিয়ে। কোন মাপকাঠি ঠিক? ব্যবহারকারী অপেক্ষা করছেন কি না, তার ওপর নির্ভর করে — পেছনের sync-এ energy, স্ক্রিনে আঙুল ছোঁয়ার সাড়ায় গতি। অংশ ৪-এর উদাহরণেও একই: race-এর EDP ৭.০৫ × ১ = ৭.০৫, ধীরে চলার ৪.৮৭৫ × ২ = ৯.৭৫ — energy-তে যে জেতে, EDP-তে সে হারে।

৬ · Embedded system আর microcontroller — এক chip-এ পুরো কম্পিউটার

Embedded system হলো অন্য একটি যন্ত্রের ভেতরে বসানো কম্পিউটার, যার কাজ নির্দিষ্ট: ওয়াশিং মেশিনের নিয়ন্ত্রক, মাইক্রোওয়েভের টাইমার, IPS বা সোলার charge controller, গাড়ির ABS, ডিজিটাল মিটার, রাউটার। এদের সাধারণ বৈশিষ্ট্য:

• নির্দিষ্ট কাজ: সাধারণত একটি firmware বছরের পর বছর একই কাজ করে; ব্যবহারকারী নতুন অ্যাপ বসান না।
• সময়ের শর্ত (real-time): মোটরের নিয়ন্ত্রণ বা airbag-এ উত্তর দেরিতে এলে তা ভুল উত্তরের সমান (অংশ ৮)।
• কম power: অনেকে ব্যাটারি বা সৌরশক্তিতে চলে, কেউ কেউ বছরের পর বছর।
• দাম: লাখ লাখ ইউনিট বানানো হয়, তাই প্রতি chip-এ সামান্য দামের পার্থক্যও বড়।
• নির্ভরযোগ্যতা: কেউ পাশে বসে restart করবে না — তাপ, কম্পন, বিদ্যুতের ওঠানামায়ও চলতে হবে (watchdog, অংশ ৭)।

Microcontroller, microprocessor আর SoC

সীমারেখা আজ ঝাপসা — অনেক MCU-তেই Wi-Fi radio আছে, আর SoC শব্দটি ছোট chip-এর জন্যও ব্যবহৃত হয়। মূল পার্থক্য দর্শনে: microcontroller নিজের ভেতরেই সম্পূর্ণ, কম দামে কম power-এ একটি কাজের জন্য; microprocessor বাইরের অনেক chip-এর ওপর নির্ভরশীল সাধারণ-উদ্দেশ্যের গতিশীল CPU; আর SoC সেই পুরো বোর্ডকে এক chip-এ গুটিয়ে আনে।

একটি microcontroller-এর memory map

MCU-তে সাধারণত virtual memory নেই — CPU-র ঠিকানাই physical ঠিকানা, আর ঠিকানা-জগৎ ভাগ করা থাকে অঞ্চলে: কোথাও flash (প্রোগ্রাম), কোথাও SRAM (ভ্যারিয়েবল, stack), কোথাও peripheral-এর register. পর্ব ৫১-এ (I/O আর bus) যে memory-mapped I/O দেখেছেন, MCU-তে তা-ই সবকিছু: একটি LED জ্বালানো মানে একটি নির্দিষ্ট ঠিকানায় store. নিচের map একটি কাল্পনিক উদাহরণ — বাস্তব chip-এর ঠিকানা তার datasheet বা reference manual-এ থাকে:

ARM Cortex-M পরিবারে এমন বিন্যাসের একটি মানক কাঠামো architecture-এই বাঁধা বলে জানা যায়: মোটামুটি 0x0000_0000 থেকে code, 0x2000_0000 থেকে SRAM, 0x4000_0000 থেকে peripheral, আর 0xE000_0000 থেকে system অঞ্চল (interrupt controller NVIC আর SysTick timer). প্রতিটি অঞ্চলের ভেতরে কী কোথায়, তা chip-নির্মাতা ঠিক করেন। RISC-V MCU-তে এমন বাঁধাধরা map নেই — প্রতিটি chip নিজের map দেয়।

জনপ্রিয় কিছু পরিবার (সংক্ষেপে)

• ARM Cortex-M: ৩২-bit, অনেক নির্মাতা লাইসেন্স নিয়ে বানান; ছোট M0/M0+ থেকে DSP আর floating point-সহ M4, M7 পর্যন্ত। আজকের MCU বাজারের বড় অংশ বলে ব্যাপকভাবে ধরা হয়।
• RISC-V MCU: খোলা ISA হওয়ায় লাইসেন্স-খরচ ছাড়া core বানানো যায়; সাম্প্রতিক বছরগুলোতে বেশ কিছু নির্মাতা RISC-V-ভিত্তিক MCU এনেছেন (যেমন ESP32-এর কিছু নতুন সংস্করণ)।
• AVR: ৮-bit; Arduino Uno-র ATmega328P সবচেয়ে পরিচিত — ১৬ MHz, ৩২ KiB flash, ২ KiB SRAM. শেখার জন্য আজও খুব জনপ্রিয়।
• ESP32: Wi-Fi আর Bluetooth-সহ সস্তা MCU; মূল সংস্করণে দুটি Xtensa core, পরের কিছু সংস্করণে RISC-V. শখের IoT প্রজেক্টে খুব প্রচলিত।

৭ · Peripheral — GPIO, timer-PWM, ADC, serial bus আর watchdog

MCU-র আসল শক্তি তার peripheral — বাইরের দুনিয়ার সাথে কথা বলার ছোট ছোট hardware block, প্রতিটি কয়েকটি register দিয়ে নিয়ন্ত্রিত। Software register-এ লেখে, hardware নিজে বাকিটা করে — CPU-কে প্রতিটি বিট হাতে নাড়তে হয় না।

GPIO — সাধারণ-কাজের pin

GPIO (general-purpose input/output) pin হয় output (LED, relay চালানো) বা input (বোতাম পড়া)। সাধারণ register: MODE বা DIR (প্রতিটি বিট একটি pin-এর দিক), OUT (output latch), IN (pin-এর বর্তমান মান), আর PULL — ভেতরের pull-up বা pull-down চালু করা, যাতে বোতাম খোলা থাকলে input ভেসে না থাকে। পর্ব ০৬-এর bit manipulation (ডেটার বিট-রূপ) এখানেই প্রতিদিনের কাজ: OUT |= (1u << 5) pin ৫ জ্বালায়, OUT &= ~(1u << 5) নেভায়।

একটি সমস্যা: |= আসলে পড়া-বদলানো-লেখা (read-modify-write) — তিনটি ধাপ। মাঝখানে একটি interrupt একই register-এর অন্য বিট বদলালে সেই বদল হারিয়ে যেতে পারে। তাই অনেক MCU-তে আলাদা SET আর CLR register থাকে: সেখানে ১ লিখলে শুধু সেই বিট সেট বা মোছা হয়, বাকিগুলো অপরিবর্তিত — একটি store-এই কাজ, ভাগাভাগির সমস্যা নেই। নিচে একটি বাস্তব ধাঁচের blink প্রোগ্রাম (উদাহরণ, ওপরের কাল্পনিক map ধরে; এখানে চালানো যায় না — আসল board লাগে):

#include <stdint.h>
#define GPIO_BASE 0x40020000u                         /* example map only */
#define GPIO_MODE (*(volatile uint32_t *)(GPIO_BASE + 0x00))
#define GPIO_SET  (*(volatile uint32_t *)(GPIO_BASE + 0x0C))   /* write 1 = set bit   */
#define GPIO_CLR  (*(volatile uint32_t *)(GPIO_BASE + 0x10))   /* write 1 = clear bit */
#define LED (1u << 5)

static void delay(volatile uint32_t n) { while (n--) { } }   /* busy wait: wastes energy */

int main(void) {
    GPIO_MODE |= LED;            /* pin 5 = output (read-modify-write, done once) */
    for (;;) {
        GPIO_SET = LED;          /* single store, no read needed */
        delay(400000);
        GPIO_CLR = LED;
        delay(400000);
    }
}

এখানে volatile জরুরি: না থাকলে compiler store-গুলো বাদ দিতে বা একত্র করতে পারে (C কোর্সের Embedded C পর্বে বিস্তারিত)। আর delay() loop শক্তির অপচয় — CPU পুরো গতিতে অকারণে ঘোরে। ভালো নকশায় timer সময় গোনে, CPU ঘুমায়। নিচের simulation সেই ধারণা দেখায় — সাধারণ মেমরিতে একটি নকল GPIO আর timer register block, আর timer-এর event-এ চলা একটি ছোট state machine:

// SIMULATION: fake GPIO + timer registers in ordinary memory (no real hardware is touched)
#include <stdio.h>
#include <stdint.h>
typedef struct { volatile uint32_t MODE, OUT, IN; } gpio_regs;       /* MODE bit = 1: output pin */
typedef struct { volatile uint32_t COUNT, CMP, FLAG; } timer_regs;   /* FLAG bit 0: compare match */
static gpio_regs fake_gpio; static timer_regs fake_tim;  /* real MCU: ((gpio_regs *)0x40020000u) */
#define GPIO (&fake_gpio)
#define TIM  (&fake_tim)
#define BIT(n)    (1u << (n))
#define SET(r, m) ((r) |= (m))
#define CLR(r, m) ((r) &= ~(m))
#define LED 5u                       /* LED on pin 5 */
enum { ON_TICKS = 2, OFF_TICKS = 3 };
static void hw_tick(void) {          /* what the timer hardware does by itself every tick */
    TIM->COUNT = TIM->COUNT + 1;
    if (TIM->COUNT >= TIM->CMP) { TIM->COUNT = 0; SET(TIM->FLAG, BIT(0)); }
}
int main(void) {
    SET(GPIO->MODE, BIT(LED));       /* configure pin 5 as output */
    TIM->CMP = OFF_TICKS;            /* start in the OFF state */
    for (int tick = 1; tick <= 12; tick++) {
        hw_tick();
        int event = (TIM->FLAG & BIT(0)) != 0;
        if (event) {                 /* state machine: OFF -> ON -> OFF ... */
            CLR(TIM->FLAG, BIT(0));  /* acknowledge the flag */
            if (GPIO->OUT & BIT(LED)) { CLR(GPIO->OUT, BIT(LED)); TIM->CMP = OFF_TICKS; }
            else                      { SET(GPIO->OUT, BIT(LED)); TIM->CMP = ON_TICKS; }
        }
        printf("tick %2d  COUNT=%u CMP=%u  OUT=0x%02X  LED %s%s\n", tick, (unsigned)TIM->COUNT,
               (unsigned)TIM->CMP, (unsigned)GPIO->OUT, (GPIO->OUT & BIT(LED)) ? "ON " : "off",
               event ? "  <- timer event" : "");
    }
    printf("duty = %d/%d = %d%%\n", ON_TICKS, ON_TICKS + OFF_TICKS, 100 * ON_TICKS / (ON_TICKS + OFF_TICKS));
    return 0;
}

tick  1  COUNT=1 CMP=3  OUT=0x00  LED off
tick  2  COUNT=2 CMP=3  OUT=0x00  LED off
tick  3  COUNT=0 CMP=2  OUT=0x20  LED ON   <- timer event
tick  4  COUNT=1 CMP=2  OUT=0x20  LED ON
tick  5  COUNT=0 CMP=3  OUT=0x00  LED off  <- timer event
tick  6  COUNT=1 CMP=3  OUT=0x00  LED off
tick  7  COUNT=2 CMP=3  OUT=0x00  LED off
tick  8  COUNT=0 CMP=2  OUT=0x20  LED ON   <- timer event
tick  9  COUNT=1 CMP=2  OUT=0x20  LED ON
tick 10  COUNT=0 CMP=3  OUT=0x00  LED off  <- timer event
tick 11  COUNT=1 CMP=3  OUT=0x00  LED off
tick 12  COUNT=2 CMP=3  OUT=0x00  LED off
duty = 2/5 = 40%

Timer আর PWM — digital pin দিয়ে “মাঝামাঝি” মান

Timer একটি hardware counter (পর্ব ১৬-এর counter), যা নিজে নিজে clock গোনে আর compare মানে পৌঁছালে event দেয়। এর সবচেয়ে কাজের ব্যবহার PWM (pulse-width modulation): pin খুব দ্রুত চালু-বন্ধ হয়, আর period-এর যে ভগ্নাংশ চালু থাকে তা duty. LED, মোটর বা heater এত দ্রুত সাড়া দেয় না, তাই তারা গড় মানটি “দেখে”:

উদাহরণ: timer clock ১৬ MHz, period ১০০০ count → f_PWM = ১৬ kHz (period ৬২.৫ µs). Compare ২৫০ হলে duty ২৫%, ৩.৩ V supply-তে গড় ০.৮২৫ V. নিচের stepper-এ একই timer-এ compare বদলে বদলে (এখানে প্রতিটি █ বা ░ period-এর ১/৮ অংশ):

1TIM_CMP = 0;      // period = 10002TIM_CMP = 250;3TIM_CMP = 500;4TIM_CMP = 750;5TIM_CMP = 1000;

ADC — analog voltage থেকে সংখ্যা

তাপমাত্রা, আলো, মাটির আর্দ্রতার sensor সাধারণত একটি voltage দেয়। ADC (analog-to-digital converter) সেই voltage-কে n-bit সংখ্যায় বদলায়। আদর্শ n-bit ADC-তে 2ⁿটি code, আর প্রতিটি code-এর ধাপ:

১২-bit, V_ref ৩.৩ V: ধাপ = ৩.৩ ÷ ৪০৯৬ ≈ ০.৮০৬ mV. ১.৬৫ V → code ২০৪৮ (ঠিক মাঝখানে)। ধাপের চেয়ে ছোট পার্থক্য ADC দেখতে পায় না — এটি quantization error, ⌊ ⌋ দিয়ে কাটলে ০ থেকে প্রায় ১ ধাপ, আর কাছের code-এ গোল করলে ±½ ধাপ। সাবধান: কিছু বই আর datasheet ধাপকে V_ref ÷ (2ⁿ − 1) হিসেবে লেখে — পরীক্ষায় কোন নিয়ম চাওয়া হয়েছে দেখে নিন। নিচের calculator দুই রূপান্তর, তিনটি ADC-র ধাপ, একটি ছোট quantisation টেবিল আর PWM-এর হিসাব একসাথে করে:

// ADC code <-> voltage and PWM duty -> average voltage (ideal converter, step = Vref / 2^n).
const step = (vref, n) => vref / 2 ** n;
const toCode = (v, vref, n) => Math.min(2 ** n - 1, Math.floor(v / step(vref, n)));
const toVolt = (code, vref, n) => code * step(vref, n);     // lower edge of the code's band
for (const [vref, n] of [[5.0, 10], [3.3, 12], [3.3, 16]])
  console.log(`${n}-bit, Vref ${vref} V: ${2 ** n} codes, step = ${(step(vref, n) * 1000).toFixed(4)} mV`);
console.log("\n12-bit, Vref 3.3 V");
for (const v of [0.5, 1.65, 2.0, 3.3]) console.log(`  ${v.toFixed(2)} V -> code ${toCode(v, 3.3, 12)}`);
for (const c of [1000, 3000]) console.log(`  code ${c} -> ${toVolt(c, 3.3, 12).toFixed(4)} V`);
console.log("\nquantisation: 3-bit ADC, Vref 8 V (step 1 V), input 0..8 V");
console.log("  input(V)  code  bits  back(V)  error(V)");
for (const v of [0.0, 0.4, 1.0, 2.7, 3.99, 5.5, 7.2, 8.0]) {
  const c = toCode(v, 8, 3), back = toVolt(c, 8, 3);
  console.log(`  ${v.toFixed(2).padStart(7)} ${String(c).padStart(5)}   ${c.toString(2).padStart(3, "0")}` +
    `${back.toFixed(2).padStart(9)}${(v - back).toFixed(2).padStart(10)}`);
}
console.log("\nPWM: timer clock 16 MHz, period register 1000 counts, supply 3.3 V");
const fPWM = 16e6 / 1000;
console.log(`  PWM frequency = ${fPWM / 1000} kHz, period = ${(1e6 / fPWM).toFixed(1)} us`);
for (const cmp of [0, 250, 500, 750, 1000]) {
  const d = cmp / 1000;
  console.log(`  compare ${String(cmp).padStart(4)}: duty ${(100 * d).toFixed(0).padStart(3)}%  ON ${(d * 62.5).toFixed(2).padStart(6)} us` +
    `  V_avg = ${(3.3 * d).toFixed(3)} V`);
}

10-bit, Vref 5 V: 1024 codes, step = 4.8828 mV
12-bit, Vref 3.3 V: 4096 codes, step = 0.8057 mV
16-bit, Vref 3.3 V: 65536 codes, step = 0.0504 mV

12-bit, Vref 3.3 V
  0.50 V -> code 620
  1.65 V -> code 2048
  2.00 V -> code 2482
  3.30 V -> code 4095
  code 1000 -> 0.8057 V
  code 3000 -> 2.4170 V

quantisation: 3-bit ADC, Vref 8 V (step 1 V), input 0..8 V
  input(V)  code  bits  back(V)  error(V)
     0.00     0   000     0.00      0.00
     0.40     0   000     0.00      0.40
     1.00     1   001     1.00      0.00
     2.70     2   010     2.00      0.70
     3.99     3   011     3.00      0.99
     5.50     5   101     5.00      0.50
     7.20     7   111     7.00      0.20
     8.00     7   111     7.00      1.00

PWM: timer clock 16 MHz, period register 1000 counts, supply 3.3 V
  PWM frequency = 16 kHz, period = 62.5 us
  compare    0: duty   0%  ON   0.00 us  V_avg = 0.000 V
  compare  250: duty  25%  ON  15.63 us  V_avg = 0.825 V
  compare  500: duty  50%  ON  31.25 us  V_avg = 1.650 V
  compare  750: duty  75%  ON  46.88 us  V_avg = 2.475 V
  compare 1000: duty 100%  ON  62.50 us  V_avg = 3.300 V

UART, I2C আর SPI — chip-এর সাথে chip-এর কথা

Sensor, display, memory chip-এর সাথে MCU কথা বলে serial bus-এ। পর্ব ৫১-এ (I/O আর bus) bus-এর সাধারণ ধারণা আছে; এখানে MCU-র তিনটি প্রচলিত পথ পাশাপাশি:

একটি হিসাব: UART-এ “8N1” ফরম্যাটে প্রতিটি byte-এ ১টি start বিট + ৮টি ডেটা বিট + ১টি stop বিট = ১০ বিট। তাই ১১৫২০০ baud-এ সর্বোচ্চ ১১৫২০০ ÷ ১০ = ১১,৫২০ byte/s — ৮ দিয়ে ভাগ করা প্রচলিত ভুল। I2C-তে প্রতিটি byte-এর পর receiver একটি ACK বিট দেয়, তাই এখানেও ৮ বিটের জন্য ৯টি clock; SPI সবচেয়ে সরল আর দ্রুত, তবে প্রতিটি device-এর জন্য বাড়তি তার।

Watchdog আর interrupt

Watchdog timer একটি গুনতে থাকা counter, যাকে software-কে নিয়মিত reset করতে (“খাওয়াতে”) হয়। Software কোথাও আটকে গেলে — অনন্ত loop, বিদ্যুতের ঝাঁকুনিতে গোলমাল — watchdog শেষ সীমায় পৌঁছে পুরো chip reset করে। মাঠে বসানো যন্ত্রে এটিই শেষ রক্ষা। আর peripheral নিজের কাজ শেষ হলে (ADC-র রূপান্তর, UART-এ byte এল, timer-এর event) CPU-কে interrupt দেয়, যাতে CPU বারবার জিজ্ঞেস না করে ঘুমিয়ে থাকতে পারে। Interrupt controller আর DMA-র hardware পর্ব ৫২-এ (Interrupt আর DMA), আর CPU-র ভেতরে trap কীভাবে সামলানো হয় তা পর্ব ৩৮-এ (Exception আর interrupt) দেখুন।

৮ · Real-time আর low-power নকশা — deadline, WCET আর duty cycling

Real-time — গড় নয়, সবচেয়ে খারাপ ক্ষেত্র

Real-time system-এ উত্তর ঠিক হওয়ার পাশাপাশি সময়মতো হতে হয়: প্রতিটি কাজের একটি deadline. Hard real-time-এ (airbag, মোটরের নিয়ন্ত্রণ) deadline ফসকানো মানে ব্যর্থতা; soft real-time-এ (ভিডিও চালানো) মাঝে মাঝে ফসকালে মান কমে। তাই এখানে প্রশ্ন “গড়ে কত দ্রুত” নয়, বরং WCET (worst-case execution time) — সবচেয়ে খারাপ ক্ষেত্রে একটি কাজ কতক্ষণ নিতে পারে।

এখানেই এই কোর্সের অনেক গতি-বাড়ানোর কৌশল ঝামেলা বাধায়। Cache (পর্ব ৪৫) গড় সময় কমায়, কিন্তু একই কোড কখনো hit, কখনো miss — সময় অনেকটা ওঠানামা করে। Branch predictor (পর্ব ৩৭), out-of-order execution (পর্ব ৪০) আর অন্য core-এর সাথে ভাগ করা bus-ও তাই। এদের সবচেয়ে খারাপ ক্ষেত্র প্রমাণ করা খুব কঠিন, আর নিরাপদ দিকে থাকতে বিশ্লেষণ প্রায়ই অনেক হতাশাজনক অনুমান দেয়। ফলে কঠোর real-time কাজের MCU-তে প্রায়ই সরল in-order pipeline, cache-এর বদলে বা পাশাপাশি নির্দিষ্ট সময়ের on-chip মেমরি (ARM-এর ভাষায় tightly-coupled memory), আর নির্দিষ্ট interrupt latency রাখা হয় — গড় গতির চেয়ে পূর্বানুমানযোগ্যতা বেশি মূল্যবান। Scheduling-এর দিক (rate monotonic, EDF) আর RTOS কীভাবে tick আর priority দিয়ে কাজ চালায়, তা OS কোর্সের Real-time scheduling আর RTOS-এর ভেতর অংশে আছে।

Low-power নকশা — প্রায় সারাক্ষণ ঘুম

একটি কাল্পনিক উদাহরণ: ধানক্ষেতের এক কোণে মাটির আর্দ্রতা মাপার একটি sensor node, দুটি AA ব্যাটারিতে (ধরা যাক ২০০০ mAh), প্রতি ১০ মিনিটে একবার মাপ পাঠায়। বর্ষায় মাঠে গিয়ে বারবার ব্যাটারি বদলানো বাস্তবসম্মত নয়, তাই লক্ষ্য মাসের পর মাস চলা। কৌশল একটিই — duty cycling: বেশিরভাগ সময় MCU গভীর ঘুমে (কয়েক µA), একটি কম-power timer নির্দিষ্ট সময় পর জাগায়, অল্প কাজ করে আবার ঘুম। গড় current:

MCU জাগে, sensor-এ power দেয়, স্থির হওয়ার অপেক্ষা,
ADC দিয়ে কয়েকবার মেপে গড় নেয়।
charge = 10 mA × 2 s = 20 mA·s

radio চালু, packet পাঠানো, ACK-এর অপেক্ষা
charge = 120 mA × 1 s = 120 mA·s
(এক চক্রের মোট charge-এর প্রায় ৮২%)

sensor, radio, ADC বন্ধ; CPU power-gated
শুধু ছোট RTC আর জাগানোর logic চালু
charge = 0.010 mA × 597 s = 5.97 mA·s

মোট = 20 + 120 + 5.97 = 145.97 mA·s প্রতি 600 s
I_avg = 145.97 ÷ 600 = 0.2433 mA
জাগা সময় মাত্র 3 ÷ 600 = 0.5%

আদর্শ: 2000 ÷ 0.2433 ≈ 8221 h ≈ 342.5 দিন
৮০% ব্যবহারযোগ্য ধরলে: 1600 ÷ 0.2433 ≈ 274 দিন
ঘুমে 10 µA-এর বদলে 2 mA হলে: মাত্র 30 দিন

একই হিসাব বিভিন্ন জাগার ব্যবধানে — কত ঘন ঘন মাপ নিলে আয়ু কত:

// Duty-cycled sensor node: average current and battery life. ALL values are ASSUMED teaching numbers.
const battery_mAh = 2000, derate = 0.8;          // usable fraction (self-discharge, cold, cut-off voltage)
const phases = [                                   // one wake-up: [name, seconds, current in mA]
  ["measure", 2, 10],
  ["radio TX", 1, 120],
];
const sleep_mA = 0.010;                            // 10 uA in deep sleep
console.log(`battery ${battery_mAh} mAh, usable ${derate * 100}%, sleep ${sleep_mA * 1000} uA`);
console.log("period    awake%   charge/period(mA*s)   I_avg(mA)   life(days)");
for (const period of [60, 300, 600, 1800, 3600]) {   // seconds between wake-ups
  let awake = 0, q = 0;
  for (const [, t, i] of phases) { awake += t; q += t * i; }
  q += (period - awake) * sleep_mA;                 // the rest of the period asleep
  const iAvg = q / period;                          // mA = (mA*s) / s
  const days = battery_mAh * derate / iAvg / 24;
  console.log(`${String(period / 60).padStart(4)} min ${(100 * awake / period).toFixed(3).padStart(8)}` +
    `${q.toFixed(2).padStart(18)}${iAvg.toFixed(4).padStart(15)}${days.toFixed(1).padStart(12)}`);
}
// What if the node never sleeps properly and idles at 2 mA instead of 10 uA?
const q2 = 2 * 10 + 1 * 120 + 597 * 2, i2 = q2 / 600;
console.log(`\n10 min period, idle 2 mA instead of sleep: I_avg = ${i2.toFixed(3)} mA, ` +
  `life = ${(battery_mAh * derate / i2 / 24).toFixed(1)} days`);

battery 2000 mAh, usable 80%, sleep 10 uA
period    awake%   charge/period(mA*s)   I_avg(mA)   life(days)
   1 min    5.000            140.57         2.3428        28.5
   5 min    1.000            142.97         0.4766       139.9
  10 min    0.500            145.97         0.2433       274.0
  30 min    0.167            157.97         0.0878       759.6
  60 min    0.083            175.97         0.0489      1363.9

10 min period, idle 2 mA instead of sleep: I_avg = 2.223 mA, life = 30.0 days

ফোনের SoC — একটি chip-এ অনেক বিশেষজ্ঞ

এই পর্বের সব ধারণা একসাথে দেখা যায় ফোনের SoC-তে। সাধারণ আধুনিক ফোনের chip-এ মোটামুটি থাকে: বড় আর ছোট CPU core, GPU (পর্ব ৫৫), AI-এর জন্য NPU, ক্যামেরার ISP (image signal processor), video-র block, অনেক ক্ষেত্রে cellular modem, আর sensor দেখার জন্য সর্বদা-জাগ্রত একটি ছোট কম-power core. প্রতিটি block আলাদা power domain-এ, নিজস্ব DVFS আর power gating-সহ — ক্যামেরা বন্ধ থাকলে ISP পুরো অন্ধকার। এটিই dark silicon-এর ইতিবাচক রূপ: অনেক বিশেষজ্ঞ, যার যখন দরকার।

৯ · AI-এর যুগে — power আর embedded-এর হিসাব যাচাই

AI টুল datasheet-এর মতো ভাষায় খুব আত্মবিশ্বাসী উত্তর দেয়, আর embedded-এ ভুল register-এর ঠিকানা বা ভুল ঘুমের current মাঠে গিয়ে তবেই ধরা পড়ে। এই বিষয়ে প্রচলিত ভুল:

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

• Power (W) আর energy (J, Wh) আলাদা করে দেখেছি; তুলনা প্রতি কাজের energy-তে
• P = α·C·V²·f-এ V বর্গে আছে কি না, আর leakage যোগ হয়েছে কি না দেখেছি
• ব্যাটারির হিসাবে mAh-কে voltage দিয়ে Wh-এ বদলেছি আর ব্যবহারযোগ্য অংশ (যেমন ৮০%) ধরেছি
• ADC-র ধাপ আর PWM-এর গড় voltage নিজে calculator-এ বসিয়ে মিলিয়েছি
• Register-এর ঠিকানা আর ঘুমের current chip-এর reference manual ও datasheet-এ খুঁজে পেয়েছি
• আসল board-এ current মেপে (multimeter বা power profiler) হিসাবের সাথে মিলিয়েছি