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

MCQ প্রশ্নব্যাংক — মাইক্রোপ্রসেসর, এমবেডেড সিস্টেম ও IoT

Microprocessors, Embedded Systems and IoT MCQ Bank — Module-wise Questions with Every Option Explained

Taught in Bangla, this practice page is an 80-question MCQ bank in course order: elimination and timing strategies, 70 questions across modules 1 to 13 in seven sections, and a timed mixed set of ten. Clicking any option opens why it is right or wrong and which lesson covers it, and each question is marked easy, medium or hard. Calculations were checked in the course's 8085 simulator, with NASM and Unicorn for 8086, in the RTOS simulator and on the virtual board, with a Python block closing each section.

এই পর্বে যা করবেন

  • বাদ দেওয়ার পদ্ধতিতে উত্তর বের করা, আর প্রতিটি distractor-এর পেছনের ভুল ধারণা চেনা
  • 8085 আর 8086-এর ছোট program পড়ে register, flag আর T-state বলা
  • 8255, 8254, 8259 আর 8251-এর control word আর count দ্রুত বানানো
  • Cortex-M-এর vector, stack frame, timer, PWM, UART আর DMA-র সংখ্যা “+১” না ভুলে হিসাব করা
  • RTOS-এর schedule, power budget, sensor-এর হিসাব আর IoT protocol-এর byte গোনা
  • ঘড়ি ধরে মিশ্র মহড়া দিয়ে নিজের প্রস্তুতি মাপা আর দুর্বল মডিউলে ফেরা

১ · কীভাবে অনুশীলন করবেন — প্রশ্নের ধরন, বাদ দেওয়া আর সময়

এই পাতা বিশ্ববিদ্যালয়ের Microprocessors & Interfacing, Microcontrollers, Embedded Systems আর IoT কোর্সের পরীক্ষা, IT ও প্রকৌশলী পদের লিখিত পরীক্ষা, firmware-এর ইন্টারভিউ আর নিজে শেখার ঝালাইয়ের জন্য। এই বিষয়ের MCQ-তে নম্বর সবচেয়ে বেশি হারায় তিন জায়গায়: এক CPU-র নিয়ম আরেকটিতে চাপানো (8085-এর borrow বনাম ARM-এর C flag), সূত্রের “+১” ভুলে যাওয়া (PSC + 1, LOAD + 1), আর একক গুলিয়ে ফেলা (crystal বনাম CPU clock, বিট বনাম byte).

প্রশ্নের চার ছাঁচ

ধরনউদাহরণকৌশল
ধারণাMicroprocessor বনাম microcontroller, firm real-time, STRIDEসংজ্ঞার প্রতিটি শব্দ মেলান
Program পড়া8085-এর flag, 8086-এর DIV, REP MOVSWখাতায় প্রতিটি নির্দেশের পরে register লিখুন
Bit আর register8255-এর control word, CRL, BRRবিটের ছক এঁকে প্রতিটি ঘর আলাদা ভরুন
হিসাবDelay loop, timer, battery-র আয়ু, packet-এর byteসূত্র লিখে একক সঙ্গে রেখে এগোন

কোন মডিউলে কতটি প্রশ্ন

Questions per module, roughly in proportion to the number of lessons; 10 more in the mixed mock

মডিউলভিত্তিক প্রশ্নের সংখ্যা চৌদ্দটি অনুভূমিক bar. মডিউল ১ থেকে ১৩-এ প্রশ্নের সংখ্যা যথাক্রমে ৫, ৭, ৭, ৬, ৫, ৬, ৫, ৬, ৫, ৪, ৪, ৬ আর ৪, মোট ৭০; মিশ্র মহড়ায় আরও ১০টি। M1 ভিত্তি৫ M2 8085৭ M3 8086৭ M4 interfacing৬ M5 Cortex-M৫ M6 embedded C৬ M7 GPIO-timer৫ M8 bus৬ M9 RTOS৫ M10 power৪ M11 sensor৪ M12 IoT৬ M13 security৪ মিশ্র মহড়া১০

কৌশল ১ · বাদ দেওয়ার পদ্ধতি — একটি 8085 flag-এর প্রশ্ন ধাপে ধাপে

“কী হবে” ধরনের প্রশ্নে প্রতিটি ভুল অপশন সাধারণত একটি ভুল মডেল থেকে আসে: register-এর মাপ ভুলে যাওয়া, অন্য CPU-র flag ধার করা, বা carry হারানো। প্রতিটি মডেল আলাদা করে পরীক্ষা করে কাটুন।

  1. প্রশ্নA আর flag?চারটি অপশন
  2. মাপখ বাদA ৮ বিট
  3. flagগ বাদOF নেই
  4. carryঘ বাদবিট ৮ = 1
  5. উত্তরকsimulator
প্রশ্ন (মাঝারি)চার অপশন
MVI A,0B5H
ADI 6EH

ক) A=23H CY=1 AC=1 P=0
খ) A=123H CY=0
গ) A=23H CY=1 OF=1
ঘ) A=23H CY=0 AC=1
ধাপ ২খ কাটুন
A একটি ৮ বিটের register
সর্বোচ্চ FFH
123H রাখতে ৯ বিট লাগে
→ খ অসম্ভব
ধাপ ৩গ কাটুন
8085-এর flag:
S Z AC P CY
OF আছে 8086-এ,
8085-এ নেই → গ বাদ
ধাপ ৪ঘ কাটুন
  B5H = 1011 0101
+ 6EH = 0110 1110
= 123H → বিট ৮ = 1
CY = 1 → ঘ বাদ
ধাপ ৫উত্তর ক
A = 23H = 0010 0011
S=0 Z=0
AC: 5 + E = 13H → 1
P: তিনটি 1 → 0
CY = 1 (F=11H)
  1. আগে প্রশ্নটি নিজের ভাষায় বলুন। দুটি ৮ বিটের সংখ্যা যোগ; জানতে হবে A-তে কী থাকে আর কোন flag বসে। চারটি অপশন চারটি আলাদা মডেল থেকে এসেছে।
  2. মাপের মডেল কাটুন। Accumulator ৮ বিটের, তাই 123H সেখানে বসতে পারে না; বাড়তি বিট যায় CY-তে। খ বাদ।
  3. ভুল CPU-র flag কাটুন। 8085-এর flag মাত্র পাঁচটি: S, Z, AC, P, CY. Overflow flag (OF) 8086-এর; গ বাদ।
  4. Carry-র মডেল কাটুন। B5H + 6EH = 123H, বিট ৮-এ 1, তাই CY = 1; ঘ বাদ।
  5. উত্তর আর যাচাই। A = 23H, নিচের nibble 5 + E থেকে AC = 1, তিনটি 1 বলে P = 0. কোর্সের simulator-এর trace-ও তাই দেখায়: A=23 … AC=1 P=0 CY=1, F = 11H.

প্রথমবার চালালে ব্রাউজারে Python নামতে কয়েক সেকেন্ড লাগতে পারে; এই পাতার সব Python block শুধু standard library ব্যবহার করে।

from fractions import Fraction as F

def add8(a, b):                        # 8085-এর ADD/ADI-এর flag নিয়ম
    r = a + b
    res = r & 0xFF
    return dict(A=f"{res:02X}H", S=res >> 7, Z=int(res == 0),
                AC=int((a & 0xF) + (b & 0xF) > 0xF),
                P=int(bin(res).count("1") % 2 == 0), CY=r >> 8)

print("B5H + 6EH →", add8(0xB5, 0x6E))
sa, sb = 0xB5 - 256, 0x6E              # signed অর্থে
print("signed:", sa, "+", sb, "=", sa + sb, "| −128..127-এর ভেতরে:", -128 <= sa + sb <= 127)

for cut in range(3):                   # negative marking: ঠিক +1, ভুল −1/4
    k = 4 - cut
    ev = F(1, k) - F(k - 1, k) * F(1, 4)
    print(f"{cut}টি বাদ দিয়ে আন্দাজ: প্রত্যাশিত নম্বর {ev} ≈ {float(ev):.3f}")

আসল আউটপুট:

B5H + 6EH → {'A': '23H', 'S': 0, 'Z': 0, 'AC': 1, 'P': 0, 'CY': 1}
signed: -75 + 110 = 35 | −128..127-এর ভেতরে: True
0টি বাদ দিয়ে আন্দাজ: প্রত্যাশিত নম্বর 1/16 ≈ 0.062
1টি বাদ দিয়ে আন্দাজ: প্রত্যাশিত নম্বর 1/6 ≈ 0.167
2টি বাদ দিয়ে আন্দাজ: প্রত্যাশিত নম্বর 3/8 ≈ 0.375

ছোট মডেলটি simulator-এর ফলই দেয়। Signed অর্থে −75 + 110 = 35, সীমার ভেতরে, তাই 8086 হলে OF-ও 0 হতো। শেষ তিন লাইন negative marking-এর হিসাব: ঠিক হলে +১ আর ভুলে −০.২৫ ধরলে অন্ধ আন্দাজের প্রত্যাশিত লাভ মাত্র ১/১৬, একটি অপশন নিশ্চিত কাটলে ১/৬, দুটি কাটলে ৩/৮. নম্বর কাটার নিয়ম পরীক্ষাভেদে আলাদা; নিজের পরীক্ষার নিয়ম দেখে নিন।

কৌশল ২ · প্রথমে CPU আর একক, তারপর সময় ভাগ

প্রশ্ন কোন CPU বা chip-এর, তা আগে চিহ্নিত করুন: বিয়োগের পরে CY = 1 মানে 8085-এ borrow, কিন্তু ARM-এ C = 1 মানে borrow হয়নি; priority-র ছোট সংখ্যা NVIC-এ বেশি জরুরি, FreeRTOS-এ কম। তারপর একক: crystal না CPU clock, বিট না byte, ms না µs. প্রথম দফায় ধারণার প্রশ্ন, দ্বিতীয় দফায় program আর হিসাব, খাতায় প্রতিটি ধাপ লিখে।

দশটি বড় ফাঁদ

ফাঁদভুল ধারণাসঠিক কথা
8085-এর clock“6 MHz crystal মানে 6 MHz”Crystal ÷ 2 = 3 MHz, এক T-state ≈ 0.333 µs (পর্ব ০৮)
Flag ধার করা“8085-এও OF আছে”8085-এ S Z AC P CY; OF, DF, IF, TF 8086-এর (পর্ব ০৭, ১৪)
Borrow-এর দিক“সব CPU-তে CY = 1 মানে borrow”8085 আর 8086-এ তাই; ARM-এ C = 1 মানে borrow হয়নি (পর্ব ০৫, ২৯)
Segment“[BP+…]-এও DS”BP থাকলে default segment SS (পর্ব ১৫)
“+১”“f = clock ÷ (PSC × ARR)”দুটিতেই +১; SysTick-এর period LOAD + 1 (পর্ব ৪৪)
Priority-র দিক“সংখ্যা বড় মানে জরুরি, সবখানে”NVIC-এ ছোট সংখ্যা জরুরি, FreeRTOS-এ বড় (পর্ব ৫৬)
volatile“volatile মানে atomic”volatile পড়া-লেখা নিশ্চিত করে, read-modify-write রক্ষা করে না (পর্ব ৩৪)
Hardware frame“ISR-এর stack শুধু তার local”প্রতি স্তরে আরও 32 byte (৮ word) (পর্ব ৩৯)
Hash বনাম সই“hash মিলেছে, তাই বিশ্বাসযোগ্য”Hash শুধু বদল ধরে; উৎসের প্রমাণ signature (পর্ব ৭৭)
Keep-alive“keep-alive পেরোলেই Will”MQTT 3.1.1-এ দেড় গুণ সময় পরে (পর্ব ৭৩)

এই পাতার প্রশ্নগুলো সম্পর্কে: প্রশ্নগুলো এই কোর্সের পর্বগুলো থেকে নতুন করে লেখা, এ ধরনের প্রশ্ন প্রায়ই আসে এমন ধারণা থেকে। কোনোটিই কোনো নির্দিষ্ট পরীক্ষা, বিশ্ববিদ্যালয় বা প্রতিষ্ঠানের আসল প্রশ্ন নয়। “বাজারঘর” একটি কাল্পনিক দোকান, আর বাজারঘর board কোর্সের virtual board, আসল Cortex-M chip-এর আদলে বানানো।

২ · মডিউল ১ ও ২ — ভিত্তি আর 8085 (১২টি প্রশ্ন)

যে পর্বগুলো ঝালিয়ে নেবেন · পর্ব ০১–১৩

মডিউল ১ — ভিত্তি (৫টি প্রশ্ন)

(সহজ) একটি 8085-ভিত্তিক board-এ program রাখতে আলাদা EPROM chip আর data রাখতে আলাদা RAM chip লাগে, অথচ ATmega328P-এর ভেতরেই 32 KB flash আর 2 KB SRAM আছে। এই পার্থক্য কোন শ্রেণিভাগ বোঝায়?

  • দুটিই microcontroller, শুধু আকার আলাদা
  • 8085 microprocessor, ATmega328P microcontroller
  • 8085 SoC, ATmega328P FPGA
  • দুটিই application SoC

(সহজ) নিচের কোন ক্রমটি সময় অনুযায়ী (আগে থেকে পরে) ঠিক?

  • 8085 → 4004 → 8086 → IBM PC
  • 4004 → 8086 → 8085 → IBM PC
  • 4004 → 8085 → IBM PC → 8086
  • 4004 → 8085 → 8086 → 8088-ভিত্তিক IBM PC

(মাঝারি) 8085-এ MVI A,0C8H তারপর ADI 64H চলল (unsigned অর্থে 200 + 100, signed অর্থে −56 + 100). কোন কথাটি ঠিক?

  • A = 2CH, CY = 1; signed ফল (+44) ঠিক, overflow হয়নি
  • A = 2CH, CY = 0, কারণ signed ফল ঠিক
  • A = 12CH, CY = 0
  • A = 2CH, CY = 1, আর 8085 overflow flag-ও 1 করে

(সহজ) দশমিক −100-এর ৮ বিটের two's complement আর দশমিক 92-এর packed BCD যথাক্রমে কী?

  • 64H আর 5CH
  • 9BH আর 92H
  • 9CH আর 92H
  • 9CH আর 5CH

(মাঝারি) একটি super loop-এ তিনটি কাজ পালাক্রমে চলে, কোনো interrupt নেই: sensor পড়া 2.5 ms, display হালনাগাদ 8 ms, বোতাম দেখা 0.2 ms. বোতাম চাপার পর সাড়া পেতে সবচেয়ে বেশি কত সময় লাগতে পারে?

  • 8 ms
  • প্রায় 10.7 ms
  • 0.2 ms
  • প্রায় 3.57 ms (তিন কাজের গড়)

মডিউল ২ — 8085 (৭টি প্রশ্ন)

(সহজ) 8085-এ CY = 0 অবস্থায় MVI A,0FFH তারপর INR A চলল। এরপর flag byte (S Z 0 AC 0 P 0 CY ক্রমে) কত?

  • 55H
  • 44H
  • 50H
  • 54H

(সহজ) 6 MHz crystal-এর 8085-এ এই অংশটি চলল: LXI H,2050H (10 T), MOV A,M (7 T), INX H (6 T), ADD M (7 T), HLT (5 T). মোট T-state আর সময় কত?

  • 35 T, প্রায় 5.83 µs
  • 33 T, 11 µs
  • 35 T, প্রায় 11.67 µs
  • 30 T, 10 µs

(মাঝারি) 8085-এর MOV r1,r2-এর opcode-ছাঁচ 01 DDD SSS, যেখানে B = 000, A = 111, M = 110. MOV B,M-এর opcode কত, আর এর addressing mode কী?

  • 46H, register indirect
  • 70H, direct
  • 7EH, register indirect
  • 46H, immediate

(মাঝারি) 8085-এ A = 59H আর B = 38H (দুটিই packed BCD). ADD B তারপর DAA চলার পরে A আর CY কত?

  • A = 91H, CY = 0
  • A = 97H, CY = 0
  • A = F7H, CY = 1
  • A = 97H, CY = 1

(মাঝারি) 8085-এ SP = 3000H. ঠিকানা 2040H-এ রাখা CALL 2100H (৩ byte) চলল। ঠিক পরে SP আর stack-এ কী থাকে?

  • SP = 3002H, [3000H] = 43H, [3001H] = 20H
  • SP = 2FFEH, [2FFFH] = 40H, [2FFEH] = 20H
  • SP = 2FFEH, [2FFFH] = 20H, [2FFEH] = 43H
  • SP = 3000H, কারণ CALL stack ছোঁয় না

(কঠিন) 3 MHz-এর 8085-এ MVI C,N / L: DCR C / JNZ L-এর T-state 14N + 4 (HLT বাদে)। প্রায় 500 µs delay-এর জন্য কোন N সবচেয়ে কাছের?

  • N = 0D6H
  • N = 0FFH
  • N = 36H
  • N = 6BH

(কঠিন) 8085-এ শুধু RST 6.5 আর RST 5.5 খোলা রাখতে (7.5 বন্ধ), জমে থাকা RST 7.5 অনুরোধ মুছতে আর SOD না ছুঁতে SIM-এর আগে A-তে কোন byte দেবেন? তারপর (কোনো অনুরোধ নেই, interrupt disabled) RIM পড়লে A কত?

  • SIM-এর জন্য 1CH, RIM-এ 04H
  • SIM-এর জন্য 0CH, RIM-এ 04H
  • SIM-এর জন্য 1BH, RIM-এ 03H
  • SIM-এর জন্য 14H, RIM-এ 07H
def add8(a, b):                        # ফল, CY, AC
    r = a + b
    return r & 0xFF, r >> 8, int((a & 0xF) + (b & 0xF) > 0xF)

def daa(a, cy, ac):                    # Spec decision 5-এর নিয়ম
    corr = 0
    if (a & 0xF) > 9 or ac:
        corr |= 0x06
    if (a >> 4) > 9 or cy or ((a >> 4) >= 9 and (a & 0xF) > 9):
        corr |= 0x60
        cy = 1
    return (a + corr) & 0xFF, cy

v, cy, ac = add8(0xC8, 0x64)
print(f"C8H + 64H: A = {v:02X}H, CY = {cy}; signed {0xC8 - 256} + 100 = {0xC8 - 256 + 100}")
print(f"−100 → {(-100) & 0xFF:02X}H; 92-এর packed BCD → {9 << 4 | 2:02X}H")
print("super loop-এর worst case:", 2.5 + 8 + 0.2, "ms")
print(f"MOV B,M = 01 000 110 = {0b01_000_110:02X}H")
v, cy, ac = add8(0x59, 0x38)
d, dcy = daa(v, cy, ac)
print(f"59H + 38H = {v:02X}H (AC = {ac}) → DAA → {d:02X}H, CY = {dcy}")
t = 10 + 7 + 6 + 7 + 5
print(f"T-state = {t}, সময় = {t / 3:.2f} µs")
for n in (0x36, 0x6B, 0xD6, 0xFF):
    print(f"N = {n:02X}H: {14 * n + 4} T = {(14 * n + 4) / 3:.2f} µs")
sim = 0b0001_1100
print(f"SIM {sim:02X}H: R7.5={sim >> 4 & 1} MSE={sim >> 3 & 1} "
      f"M7.5,M6.5,M5.5={sim >> 2 & 1}{sim >> 1 & 1}{sim & 1}")

আসল আউটপুট:

C8H + 64H: A = 2CH, CY = 1; signed -56 + 100 = 44
−100 → 9CH; 92-এর packed BCD → 92H
super loop-এর worst case: 10.7 ms
MOV B,M = 01 000 110 = 46H
59H + 38H = 91H (AC = 1) → DAA → 97H, CY = 0
T-state = 35, সময় = 11.67 µs
N = 36H: 760 T = 253.33 µs
N = 6BH: 1502 T = 500.67 µs
N = D6H: 3000 T = 1000.00 µs
N = FFH: 3574 T = 1191.33 µs
SIM 1CH: R7.5=1 MSE=1 M7.5,M6.5,M5.5=100

Block-এর ছোট daa ফাংশন reference lab-এর Spec decision 5-এর নিয়ম মানে। 8085-এর প্রশ্নগুলো কোর্সের simulator-এও চালানো হয়েছে (সত্যিকারের run, sim8085.py, Python 3.13.5); কয়েকটি লাইন:

q06 (INR A, PUSH PSW, POP B):  A=00 … C=54   Flags: S=0 Z=1 AC=1 P=1 CY=0   (F=54H)
q07 (LXI/MOV/INX/ADD/HLT):     A=5F   Instructions: 5   T-states: 35
q10 (59H + 38H, DAA):          A=97 B=38   Flags: S=1 Z=0 AC=0 P=0 CY=0   (F=80H)
q11 (CALL at 2040H):           SP=2FFE PC=2101   2FFEH: 43 20
q12 (MVI C,6BH delay):         Instructions: 216   T-states: 1507
q13 (MVI A,1CH, SIM, RIM):     A=04 … SP=0000

q12-এর 1507-এর মধ্যে HLT-এর ৫ T আছে, তাই loop নিজে 1502 T. q10-এ DAA-র পরে S = 1, কারণ 97H-এর বিট ৭ = 1; BCD-র প্রশ্নে S-এর কোনো অর্থ নেই, শুধু A আর CY দেখুন।

৩ · মডিউল ৩ ও ৪ — 8086 আর interfacing chip (১৩টি প্রশ্ন)

যে পর্বগুলো ঝালিয়ে নেবেন · পর্ব ১৪–২৭

মডিউল ৩ — 8086 (৭টি প্রশ্ন)

(সহজ) 8086-এ CS = 2500H আর IP = 0F3CH. পরের instruction কোন physical address থেকে আসবে?

  • 0343CH
  • 25F3CH
  • 2500F3CH
  • 26F3CH

(মাঝারি) 8086-এ DS = 2000H, SS = 4000H, BP = 0100H, DI = 0008H. MOV AX,[BP+DI+4] কোন physical address থেকে পড়ে?

  • 2010CH
  • 40108H
  • 4010CH
  • 6010CH

(মাঝারি) 8086-এ mov ax, 1000 আর mov bl, 11, তারপর div bl. শেষে AX কত?

  • 0A5AH
  • 5A0AH
  • 005AH
  • Type 0 divide error

(মাঝারি) 8086-এ AL = 80H, তারপর cmp al, 7Fh. JA আর JL-এর মধ্যে কোনটি লাফাবে?

  • শুধু JA
  • শুধু JL
  • কোনোটিই নয়
  • দুটিই

(মাঝারি) 8086-এ cld, SI = 0100H, DI = 0200H, CX = 3, তারপর rep movsw. শেষে SI, DI আর CX কত?

  • SI = 0103H, DI = 0203H, CX = 0
  • SI = 0106H, DI = 0206H, CX = 0
  • SI = 00FAH, DI = 01FAH, CX = 0
  • SI = 0106H, DI = 0206H, CX = 3

(কঠিন) 8086-এর একটি near procedure শুরু হয় push bp আর mov bp,sp দিয়ে। Caller ডাকার আগে তিনটি word parameter p1, p2, p3 এই ক্রমে push করেছিল। p1 কোথায়, আর শেষে কোন নির্দেশ parameter-গুলোও সরায়?

  • [bp+4], RET 3
  • [bp+2], RET 6
  • [bp+8], RET 6
  • [bp+6], RET 4

(সহজ) 8086-এ INT 1Ch-এর interrupt vector কোন physical address-এ, আর কোন ক্রমে কী থাকে?

  • 00070H–00073H; আগে IP, পরে CS
  • 0001CH–0001FH; আগে IP, পরে CS
  • 00070H–00073H; আগে CS, পরে IP
  • 00038H–0003BH; আগে IP, পরে CS

মডিউল ৪ — memory, I/O আর peripheral chip (৬টি প্রশ্ন)

(সহজ) একটি 16K × 8 EPROM-কে 4000H থেকে বসানো হলো। তার শেষ ঠিকানা কত, আর chip-এর ভেতরের ঘর বাছতে কয়টি address line লাগে?

  • 8000H, ১৪টি
  • 7FFFH, ১৬টি
  • 43FFH, ১০টি
  • 7FFFH, ১৪টি

(মাঝারি) একটি 8085 system-এ 74LS138-এর C B A-তে A15 A14 A13, আর enable সব সক্রিয় (IO/M̅ = 0 সহ)। 6000H–7FFFH-এর RAM কোন output-এ বসাবেন?

  • Y6
  • Y3
  • Y1
  • Y7

(মাঝারি) 8255-এ port A output, port B input, port C-এর ওপরের অর্ধেক input, নিচের অর্ধেক output, সবই mode 0. Control word কত, আর PC3-কে 1 করার BSR word কত?

  • 8AH আর 06H
  • 98H আর 07H
  • 8AH আর 07H
  • 0AH আর 87H

(মাঝারি) 8254-এর CLK = 2.5 MHz. Counter 0-কে mode 3-এ 500 Hz square wave দিতে, LSB তারপর MSB, binary-তে চালাতে count আর control word কত?

  • 5000 (1388H), 36H
  • 5000 (1388H), 76H
  • 500 (01F4H), 36H
  • 5000 (1388H), 37H

(মাঝারি) 8086 mode-এ একটি 8259-এর ICW2 = 70H. IR3 থেকে interrupt এলে CPU কোন type পায়, আর তার vector কোন ঠিকানায়?

  • 70H, 001C0H
  • 73H, 00073H
  • 7BH, 001ECH
  • 73H, 001CCH

(কঠিন) 8251A-কে async, ×64 baud factor, ৮টি data বিট, odd parity আর ২টি stop বিটে চালাতে mode word কত? (বিন্যাস: D7 D6 = stop, D5 = EP, D4 = PEN, D3 D2 = দৈর্ঘ্য, D1 D0 = baud factor)

  • FFH
  • DFH
  • CFH
  • 5FH
def pa(seg, off):                      # physical address = segment × 10H + offset
    return (seg * 0x10 + off) & 0xFFFFF

print(f"CS:IP 2500H:0F3CH → {pa(0x2500, 0x0F3C):05X}H")
ea = (0x0100 + 0x0008 + 4) & 0xFFFF
print(f"[BP+DI+4]: EA = {ea:04X}H, SS → {pa(0x4000, ea):05X}H, (ভুল) DS → {pa(0x2000, ea):05X}H")
q, r = divmod(1000, 11)
print(f"1000 ÷ 11: AL = {q:02X}H, AH = {r:02X}H → AX = {r << 8 | q:04X}H")
print(f"80H − 7FH: unsigned 128 > 127 → {128 > 127}, signed −128 < 127 → {-128 < 127}")
print(f"REP MOVSW ×3: SI = {0x0100 + 6:04X}H, DI = {0x0200 + 6:04X}H")
print(f"INT 1Ch-এর vector: {0x1C * 4:05X}H–{0x1C * 4 + 3:05X}H")
print(f"16 KB, 4000H থেকে → শেষ {0x4000 + 16 * 1024 - 1:04X}H, লাইন {(16 * 1024).bit_length() - 1}টি")
print("6000H আর 7FFFH-এর A15 A14 A13:", 0x6000 >> 13, 0x7FFF >> 13)
cw = 1 << 7 | 0 << 4 | 1 << 3 | 1 << 1 | 0     # A out, C-ওপর in, B in, C-নিচ out
print(f"8255 CW = {cw:02X}H, BSR PC3 set = {3 << 1 | 1:02X}H")
n = 2_500_000 // 500
print(f"8254: N = {n} = {n:04X}H, CW = {0b00_11_011_0:02X}H")
print(f"8259: type = {0x70 | 3:02X}H, vector = {(0x70 | 3) * 4:05X}H")
mode = 0b11 << 6 | 0 << 5 | 1 << 4 | 0b11 << 2 | 0b11   # ২ stop, odd, PEN, ৮ বিট, ×64
print(f"8251 mode word = {mode:02X}H")

আসল আউটপুট:

CS:IP 2500H:0F3CH → 25F3CH
[BP+DI+4]: EA = 010CH, SS → 4010CH, (ভুল) DS → 2010CH
1000 ÷ 11: AL = 5AH, AH = 0AH → AX = 0A5AH
80H − 7FH: unsigned 128 > 127 → True, signed −128 < 127 → True
REP MOVSW ×3: SI = 0106H, DI = 0206H
INT 1Ch-এর vector: 00070H–00073H
16 KB, 4000H থেকে → শেষ 7FFFH, লাইন 14টি
6000H আর 7FFFH-এর A15 A14 A13: 3 3
8255 CW = 8AH, BSR PC3 set = 07H
8254: N = 5000 = 1388H, CW = 36H
8259: type = 73H, vector = 001CCH
8251 mode word = DFH

8086-এর তিনটি প্রশ্ন কোর্সের runner-এও চালানো হয়েছে (সত্যিকারের run, run8086.py --regs: NASM 3.02, BSD-2-Clause; Unicorn 2.1.4, binding BSD, engine GPLv2). Runner-এ clock count নেই (Spec decision 16), তাই এই প্রশ্নগুলোতে সময়ের কথা নেই:

q16 (div bl):     AX=0A5A BX=000B … --I------
q17 (cmp, JA/JL): AX=0080 BX=0003 … --I----P-
q18 (rep movsw):  … CX=0000 … SI=0106 DI=0206 … --I------

q17-এর BX = 3 মানে দুটি শাখাই চলেছে (JA বিট ০, JL বিট ১). প্রতিটি লাফের আগে cmp আবার চালানো হয়েছিল, কারণ মাঝের or flag বদলায়; শেষ লাইনের flag (P = 1, OF = 0) তাই শেষ or bx, 2-এর, cmp-এর নয়।

৪ · মডিউল ৫ ও ৬ — Cortex-M আর embedded C (১১টি প্রশ্ন)

যে পর্বগুলো ঝালিয়ে নেবেন · পর্ব ২৮–৪০

মডিউল ৫ — microcontroller আর Cortex-M (৫টি প্রশ্ন)

(সহজ) নিচের কোন chip-এর CPU core RISC-V ISA-র?

  • ATmega328P
  • STM32F103
  • ESP32-C3
  • Intel 8051

(মাঝারি) একটি Cortex-M3-এ bootloader-এর পরে application-এর জন্য VTOR = 0x08004000. IRQ5-এর handler-এর ঠিকানা vector table-এর কোন word-এ থাকে?

  • 0x08004054
  • 0x08004014
  • 0x08000054
  • 0x08004058

(মাঝারি) একটি Cortex-M3-এ SysTick আর EXTI0 দুটিরই priority byte 0x40. SysTick handler চলার সময় EXTI0 pending হলো। কী ঘটবে?

  • EXTI0 সঙ্গে সঙ্গে SysTick-কে থামিয়ে চলবে
  • EXTI0 হারিয়ে যাবে
  • HardFault হবে
  • SysTick শেষ হলে EXTI0 চলবে (tail-chaining)

(মাঝারি) FPU-হীন Cortex-M3-এ exception-এ ঢোকার পরে MSP = 0x20004FC0 (alignment-এর pad নেই)। Stacked LR কোন ঠিকানায়?

  • 0x20004FC4
  • 0x20004FD4
  • 0x20004FD8
  • 0x20004FBC

(কঠিন) একটি firmware ধরে নিয়েছে core 8 MHz-এ চলে, তাই SysTick-এ LOAD = 7999 দিয়ে 1 ms tick সাজিয়েছে। কিন্তু clock tree সাজানোর পরে core আসলে 72 MHz-এ চলছে। Tick কত সময় পরপর আসবে?

  • 1 ms
  • 9 ms
  • প্রায় 111.1 µs
  • 125 ns

মডিউল ৬ — embedded C আর toolchain (৬টি প্রশ্ন)

(সহজ) একটি peripheral-এর status register শুধু পড়া যায়, আর hardware যেকোনো সময় তার মান বদলায়। C-তে তার pointer-এর জন্য কোন ঘোষণা সবচেয়ে উপযুক্ত?

  • volatile const uint32_t *sr
  • const uint32_t *sr
  • uint32_t *sr
  • static uint32_t sr

(মাঝারি) একটি ৩২ বিটের register-এর মান 0x000000FF. বিট ৬–৪-এর ৩ বিটের field-এ 5 বসাতে reg = (reg & ~(7u << 4)) | (5u << 4); চালানো হলো। নতুন মান কত?

  • 0x000000FF
  • 0x0000005F
  • 0x000000F5
  • 0x000000DF

(মাঝারি) ৩২ বিটের ARM-এ (AAPCS) struct { uint16_t a; uint32_t b; uint8_t c; }-এর offsetof(b) আর sizeof কত?

  • 2 আর 7
  • 4 আর 12
  • 4 আর 9
  • 8 আর 16

(মাঝারি) একটি 1 ms-এর SysTick ISR-এ polled UART-এ 9600 baud, 8N1-এ ২০টি অক্ষরের একটি debug লাইন ছাপা হয়। ISR প্রায় কতক্ষণ আটকে থাকে, আর ফল কী?

  • প্রায় 2 ms; একটি tick হারায়
  • প্রায় 16.7 ms; কিছু হারায় না
  • প্রায় 20.8 ms; প্রায় ২০টি tick-এর সময় ধরে আটকে, tick হারায়
  • প্রায় 2.08 µs; নগণ্য

(কঠিন) একটি Cortex-M3 firmware-এ main-এর সবচেয়ে গভীর call-পথ 96 byte stack নেয়। SysTick ISR নিজে 24 byte নেয়, আর EXTI0 ISR (SysTick-এর চেয়ে জরুরি, তাই তাকে থামাতে পারে) নেয় 16 byte. FPU নেই, SP সবসময় 8-এর গুণিতক ধরুন। সবচেয়ে খারাপ stack-এর ব্যবহার কত?

  • 200 byte
  • 136 byte
  • 168 byte
  • 96 byte

(মাঝারি) Q15-এ 0x4000 (0.5) আর 0xE000 গুণ করে, অর্ধেক ধাপ (214) যোগ করে ১৫ বিট ডানে সরানো হলো। 0xE000-এর মান আর গুণফলের Q15 রূপ কী?

  • 0xE000 = 0.75, গুণফল 0x3000
  • 0xE000 = −0.25, গুণফল 0xE000
  • 0xE000 = −0.25, গুণফল 0x7000
  • 0xE000 = −0.25, গুণফল 0xF000 (−0.125)
vtor = 0x08004000
print(f"IRQ5 → exception {16 + 5}, vector-এর ঘর {vtor + 4 * (16 + 5):#010x}")
names = ["R0", "R1", "R2", "R3", "R12", "LR", "PC", "xPSR"]
sp = 0x20004FC0
print(", ".join(f"{n}@{sp + 4 * i:#x}" for i, n in enumerate(names) if i >= 4))
print(f"LOAD 7999, 72 MHz → {(7999 + 1) / 72e6 * 1e6:.1f} µs পরপর tick")
reg = 0xFF
print(f"field-এ 5: {(reg & ~(7 << 4)) | (5 << 4):#04x}")

def layout(fields):                    # (নাম, মাপ); AAPCS-এ alignment = মাপ
    off, out = 0, []
    for name, size in fields:
        off = (off + size - 1) // size * size
        out.append((name, off))
        off += size
    big = max(s for _, s in fields)
    return out, (off + big - 1) // big * big

print("struct:", layout([("a", 2), ("b", 4), ("c", 1)]))
print(f"২০ অক্ষর, 9600 baud, 8N1: {20 * 10 / 9600 * 1000:.1f} ms")
print("stack-এর worst case:", 96 + (32 + 24) + (32 + 16), "byte")

def q15(v):
    return v - 65536 if v & 0x8000 else v

p = q15(0x4000) * q15(0xE000)
r = (p + (1 << 14)) >> 15
print(f"0xE000 = {q15(0xE000) / 32768}, গুণফল = {r & 0xFFFF:#06x} = {r / 32768}")

আসল আউটপুট:

IRQ5 → exception 21, vector-এর ঘর 0x08004054
R12@0x20004fd0, LR@0x20004fd4, PC@0x20004fd8, xPSR@0x20004fdc
LOAD 7999, 72 MHz → 111.1 µs পরপর tick
field-এ 5: 0xdf
struct: ([('a', 0), ('b', 4), ('c', 8)], 12)
২০ অক্ষর, 9600 baud, 8N1: 20.8 ms
stack-এর worst case: 200 byte
0xE000 = -0.25, গুণফল = 0xf000 = -0.125

layout ফাংশন AAPCS-এর সরল নিয়ম মানে: প্রতিটি field নিজের মাপের গুণিতকে বসে, আর পুরো struct-এর মাপ সবচেয়ে বড় field-এর গুণিতক। আসল compiler-এর মান মেলাতে C-তে _Static_assert(offsetof(...) == 4) লেখাই নিরাপদ অভ্যাস (পর্ব ৩৬)। Stack-এর হিসাবে SP 8-এর গুণিতক না হলে প্রতি স্তরে আরও 4 byte pad আসতে পারে, তখন সবচেয়ে খারাপ 208 byte.

৫ · মডিউল ৭ ও ৮ — GPIO, timer, DMA আর bus (১১টি প্রশ্ন)

যে পর্বগুলো ঝালিয়ে নেবেন · পর্ব ৪১–৫৩

মডিউল ৭ — GPIO, interrupt, timer, PWM আর DMA (৫টি প্রশ্ন)

(মাঝারি) STM32F103-এ (RM0008) GPIOA_CRL = 0x44444444. PA2-কে general-purpose push-pull output, সর্বোচ্চ 10 MHz (MODE = 01, CNF = 00) বানালে নতুন CRL কত?

  • 0x44444414
  • 0x44444244
  • 0x44444144
  • 0x44444544

(সহজ) একটি shift-register debouncer প্রতি 5 ms-এ বোতাম পড়ে, আর পরপর ৮টি নমুনা 1 হলে চাপ মানে। বোতাম স্থিরভাবে চাপা হওয়ার পর (আর লাফ নেই) চাপ মানতে কত দেরি?

  • 5 ms
  • প্রায় 35 থেকে 40 ms
  • 80 ms
  • 8 ms

(মাঝারি) একটি STM32 timer-এর clock 72 MHz, upcounting. কোন PSC আর ARR-এর জোড়া ঠিক 50 Hz update event দেয়?

  • PSC = 71, ARR = 19999
  • PSC = 72, ARR = 20000
  • PSC = 71, ARR = 1999
  • PSC = 7199, ARR = 19999

(মাঝারি) Timer clock 72 MHz, PSC = 0, ARR = 3599, edge-aligned PWM mode 1, CCR = 900. PWM-এর frequency, duty আর মোটামুটি resolution কত?

  • 20 kHz, 25%, ৮ বিট
  • 2 kHz, 25%, প্রায় 11.8 বিট
  • 20 kHz, প্রায় 25.01%, প্রায় 11.8 বিট
  • 20 kHz, 25%, প্রায় 11.8 বিট

(কঠিন) একটি DMA channel circular mode-এ, CNDTR-এর শুরুর মান 10, HTIE আর TCIE চালু। পরপর ২৭টি transfer-এর পরে CNDTR কত, আর মোট কয়টি interrupt এসেছে?

  • CNDTR = 0, interrupt ২টি
  • CNDTR = 3, interrupt ৫টি
  • CNDTR = 7, interrupt ৫টি
  • CNDTR = 3, interrupt ২টি

মডিউল ৮ — analog আর communication interface (৬টি প্রশ্ন)

(সহজ) একটি ১০ বিটের ADC-র Vref = 5 V. Input 2.0 V হলে আদর্শ code প্রায় কত, আর এক LSB কত?

  • 1638, 1.22 mV
  • 400, 5 mV
  • প্রায় 409, প্রায় 4.88 mV
  • 102, 19.5 mV

(সহজ) একটি ৮ বিটের R-2R DAC, Vref = 5 V, output = Vref × code ÷ 256. Code 0xC0 লিখলে output কত?

  • 3.75 V
  • 3.76 V
  • 2.50 V
  • 4.69 V

(মাঝারি) STM32F1-ধাঁচের UART-এ baud = fCK ÷ (16 × USARTDIV); BRR-এ USARTDIV-এর পূর্ণ অংশ বিট ১৫–৪-এ, ষোলো ভাগের ভগ্নাংশ বিট ৩–০-এ। fCK = 36 MHz-এ 9600 baud-এর BRR কত?

  • 0x0EA0
  • 0x0234
  • 0x0EA3
  • 0x0EA6

(মাঝারি) TMP102-ধাঁচের sensor-এর temperature register-এ (১২ বিটের two's complement, বাঁ-ঘেঁষা, 0.0625 °C/LSB) দুই byte এলো 0xE7 আর 0x00. তাপমাত্রা কত?

  • +231.0 °C
  • −25.0 °C
  • −24.9375 °C
  • +14.4375 °C

(মাঝারি) দুটি CAN node একই মুহূর্তে standard ID 0x2A0 আর 0x29F-এর data frame পাঠাতে শুরু করল। কে জিতবে, আর ৮ byte data-র এমন একটি frame stuff বিট ছাড়া কত বিটের?

  • 0x2A0, 108 বিট
  • 0x29F, 76 বিট
  • 0x29F, 108 বিট
  • দুটিই হেরে পরে আবার পাঠাবে

(সহজ) একটি Modbus RTU slave-এর ঠিকানা 1. Master FC 06 (একটি register লেখা) দিয়ে এমন একটি register-এ লিখতে চাইল যা নেই, CRC ঠিক। Slave-এর উত্তরের প্রথম তিন byte কী?

  • 01 86 02
  • 01 06 02
  • 01 83 02
  • কোনো উত্তর নেই
crl = 0x44444444
crl = (crl & ~(0xF << 8)) | (0b0001 << 8)          # PA2: CNF 00, MODE 01
print(f"CRL = {crl:#010x}; debounce {7 * 5} থেকে {8 * 5} ms")
for psc, arr in ((71, 19999), (72, 20000), (71, 1999), (7199, 19999)):
    print(f"PSC {psc}, ARR {arr}: {72e6 / ((psc + 1) * (arr + 1)):.2f} Hz")
print(f"PWM: {72e6 / 3600:.0f} Hz, duty {900 / 3600:.0%}")
cnd, irq = 10, 0
for k in range(27):                                 # circular DMA, HT আর TC
    cnd -= 1
    if cnd == 5:
        irq += 1                                    # half transfer
    if cnd == 0:
        irq += 1                                    # transfer complete
        cnd = 10                                    # নিজে reload
print("DMA: CNDTR =", cnd, ", interrupt =", irq)
print(f"ADC: {2.0 / 5 * 1024:.1f} → 409, LSB {5 / 1024 * 1000:.2f} mV; DAC 0xC0 → {5 * 0xC0 / 256} V")
div = 36e6 / (16 * 9600)
m, f = int(div), round((div % 1) * 16)
print(f"USARTDIV {div} → BRR {m << 4 | f:#06x}")
t = 0xE700 >> 4
t = t - 4096 if t & 0x800 else t
print("TMP102 0xE7 0x00:", t * 0.0625, "°C")
a, b = 0x2A0, 0x29F
bit = max(i for i in range(11) if (a ^ b) >> i & 1)
print(f"প্রথম অমিল বিট {bit}: 0x2A0 দেয় {a >> bit & 1}, 0x29F দেয় {b >> bit & 1}; frame {44 + 8 * 8} বিট")
print(f"Modbus exception-এর function code = {0x06 | 0x80:#04x}")

আসল আউটপুট:

CRL = 0x44444144; debounce 35 থেকে 40 ms
PSC 71, ARR 19999: 50.00 Hz
PSC 72, ARR 20000: 49.31 Hz
PSC 71, ARR 1999: 500.00 Hz
PSC 7199, ARR 19999: 0.50 Hz
PWM: 20000 Hz, duty 25%
DMA: CNDTR = 3 , interrupt = 5
ADC: 409.6 → 409, LSB 4.88 mV; DAC 0xC0 → 3.75 V
USARTDIV 234.375 → BRR 0x0ea6
TMP102 0xE7 0x00: -25.0 °C
প্রথম অমিল বিট 5: 0x2A0 দেয় 1, 0x29F দেয় 0; frame 108 বিট
Modbus exception-এর function code = 0x86

PSC/ARR-এর চার লাইন একসঙ্গে দেখায় “+১” ভুলে গেলে ফল কতটা সরে। DMA-র ছোট loop circular mode-এর তিনটি নিয়ম মানে: প্রতিটি transfer-এ CNDTR এক কমে, অর্ধেকে HT, শূন্যে TC আর reload. CAN-এর লাইনে প্রথম অমিল বিটটি বের করা হয়েছে XOR দিয়ে: যার সেই বিট 0, সে-ই dominant, তাই জেতে।

৬ · মডিউল ৯ ও ১০ — RTOS, power আর নির্ভরযোগ্যতা (৯টি প্রশ্ন)

যে পর্বগুলো ঝালিয়ে নেবেন · পর্ব ৫৪–৬৪

মডিউল ৯ — real-time আর RTOS (৫টি প্রশ্ন)

(সহজ) নিচের কোন জোড়াটি deadline-এর শ্রেণির সঙ্গে ঠিক মেলে?

  • গাড়ির airbag — soft
  • ভিডিও কল — hard
  • ঠান্ডা ঘরের প্রতি সেকেন্ডের reading, দেরি হলে ফেলে দেওয়া হয় — hard
  • ঠান্ডা ঘরের প্রতি সেকেন্ডের reading, দেরি হলে ফেলে দেওয়া হয় — firm

(মাঝারি) একটি firmware-এ ৩২ বিটের unsigned tick counter প্রতি 10 ms-এ এক বাড়ে। কত দিন পরে এটি ঘুরে (wrap) 0 থেকে শুরু হয়, আর সময় পেরোনোর তুলনা কীভাবে লেখা নিরাপদ?

  • প্রায় 49.7 দিন; now >= next
  • প্রায় 497.1 দিন; (int32_t)(now - next) >= 0
  • প্রায় 497.1 দিন; now >= next
  • কখনো wrap হয় না

(মাঝারি) তিনটি periodic task, deadline = period, rate-monotonic priority: ALARM (C = 1, T = 5), ADC (C = 2, T = 8), LOG (C = 2, T = 10). Utilization, Liu–Layland পরীক্ষা আর LOG-এর worst-case response time কী?

  • U = 0.65; সীমার ওপরে, তাই unschedulable
  • U = 0.65; schedulable, R(LOG) = 2
  • U = 0.65 ≤ 0.7798, তাই schedulable; R(LOG) = 5
  • U = 0.80; R(LOG) = 10

(মাঝারি) একটি RTOS-এ L (priority 1) t = 0-তে একটি mutex নিয়ে 4 tick কাজ করে ছাড়ে, তারপর আরও 1 tick চলে; H (3) t = 2-তে আসে, 1 tick চলে সেই mutex চায়, পেলে 2 tick চলে; M (2) t = 4-তে আসে, 6 tick চলে, mutex ছোঁয় না। বড় সংখ্যা বেশি জরুরি। Priority inheritance ছাড়া আর সহ H-এর response time কত?

  • 11 tick আর 5 tick
  • 5 tick আর 11 tick
  • 6 tick আর 9 tick
  • দুটিতেই 11 tick

(মাঝারি) একটি receiver task সবচেয়ে খারাপে 47 tick ব্যস্ত থাকে (অন্যদের বাধাসহ), আর producer প্রতি 8 tick-এ একটি item পাঠায়। Phase অজানা হলে queue-র ন্যূনতম নিরাপদ গভীরতা কত?

  • 5
  • 47
  • 1
  • 6

মডিউল ১০ — power, নির্ভরযোগ্যতা আর testing (৪টি প্রশ্ন)

(মাঝারি) একটি যন্ত্র প্রতি 5 s-এ 50 ms জেগে 12 mA টানে, বাকি 4.95 s-এ 5 µA. 1000 mAh battery, derating 0.7 ধরলে গড় current আর আয়ু প্রায় কত?

  • 12 mA, প্রায় 58 ঘণ্টা
  • প্রায় 0.125 mA, প্রায় ২৩৩ দিন
  • প্রায় 0.125 mA, প্রায় ৩৩৩ দিন
  • প্রায় 0.120 mA, প্রায় ২৪৩ দিন

(মাঝারি) STM32F103-এর IWDG-এ PR = 4 (÷64) আর RLR = 624. Timeout = 4 × 2PR × (RLR + 1) ÷ fLSI, আর LSI 30 থেকে 60 kHz-এর যেকোনো মান হতে পারে (typical 40 kHz). Typical timeout আর পাল্লা কত?

  • 1.0 s, কোনো পাল্লা নেই
  • 15.6 ms, পাল্লা 10.4 থেকে 20.8 ms
  • 1.0 s, পাল্লা প্রায় 0.67 থেকে 1.33 s
  • 1.0 s, পাল্লা 0.5 থেকে 2.0 s

(মাঝারি) TMR-এ প্রতিটি channel-এর নির্ভরযোগ্যতা R = 0.95, voter নিখুঁত। RTMR = 3R² − 2R³ কত, আর কখন TMR একক channel-এর চেয়ে খারাপ?

  • প্রায় 0.99275; R < 0.5 হলে
  • 0.95; কখনো নয়
  • প্রায় 0.857; R < 0.9 হলে
  • প্রায় 0.99988; R > 0.5 হলে

(মাঝারি) Cold-room alarm বন্ধের নিয়ম: পরপর ৩টি reading 0.50 থেকে 7.50 °C-এর মধ্যে (দুই প্রান্তসহ)। Sensor-এর ধাপ 0.0625 °C. Boundary value analysis-এ কোন test-গুচ্ছ এই নিয়ম সবচেয়ে ভালো যাচাই করে?

  • 4.00 °C তিনবার
  • 20.00 °C আর −10.00 °C
  • 7.50 °C একবার
  • 0.50 আর 7.50 °C, আর ঠিক বাইরের 0.4375 আর 7.5625 °C, প্রতিটি তিনবার
import math

def rta(tasks):                        # (C, T), priority-র ক্রমে, উঁচু আগে
    out = []
    for i, (c, t) in enumerate(tasks):
        r = c
        for _ in range(100):
            nxt = c + sum(math.ceil(r / tj) * cj for cj, tj in tasks[:i])
            if nxt == r or nxt > t:
                break
            r = nxt
        out.append(nxt)
    return out

ts = [(1, 5), (2, 8), (2, 10)]
n = len(ts)
print(f"U = {sum(c / t for c, t in ts):.4f}, সীমা = {n * (2 ** (1 / n) - 1):.4f}, R = {rta(ts)}")
print(f"wrap: 10 ms tick → {2 ** 32 * 0.01 / 86400:.1f} দিন, 1 ms → {2 ** 32 * 0.001 / 86400:.2f} দিন")
print("queue-র গভীরতা:", math.ceil(47 / 8))
avg = (12 * 0.05 + 0.005 * 4.95) / 5
print(f"গড় {avg:.5f} mA; আয়ু {1000 * 0.7 / avg:.0f} h = {1000 * 0.7 / avg / 24:.1f} দিন "
      f"(derating ছাড়া {1000 / avg / 24:.1f} দিন)")
for f in (40e3, 60e3, 30e3):
    print(f"IWDG, LSI {f / 1e3:.0f} kHz: {4 * 2 ** 4 * 625 / f:.3f} s")
R = 0.95
print(f"TMR {3 * R**2 - 2 * R**3:.5f}, R³ {R**3:.6f}, সমান্তরাল {1 - (1 - R)**3:.6f}")

আসল আউটপুট:

U = 0.6500, সীমা = 0.7798, R = [1, 3, 5]
wrap: 10 ms tick → 497.1 দিন, 1 ms → 49.71 দিন
queue-র গভীরতা: 6
গড় 0.12495 mA; আয়ু 5602 h = 233.4 দিন (derating ছাড়া 333.5 দিন)
IWDG, LSI 40 kHz: 1.000 s
IWDG, LSI 60 kHz: 0.667 s
IWDG, LSI 30 kHz: 1.333 s
TMR 0.99275, R³ 0.857375, সমান্তরাল 0.999875

RTOS-এর দুটি প্রশ্ন কোর্সের rtos_sim.py-তেও চালানো হয়েছে (সত্যিকারের run). প্রথমটি analyze, দ্বিতীয়টি demo inversion আর demo inversion --inherit:

U = 1/5 + 2/8 + 2/10 = 0.6500
Liu-Layland bound n(2^(1/n)-1) for n=3: 0.7798
U <= bound: schedulable under RM (sufficient test)
  R(ALARM) = 1  (deadline 5) OK
  R(ADC) = 3  (deadline 8) OK
  R(LOG) = 5  (deadline 10) OK

without inheritance:  H released 2 start 2 finish 13 response 11
                      M released 4 start 4 finish 10 response 6
with inheritance:     H released 2 start 2 finish 7 response 5
                      M released 4 start 7 finish 13 response 9

এখানে priority rate-monotonic, তাই simulator-এর “schedulable under RM” লাইন সত্যিকারের রায়; অন্য ক্রমের priority-তে সেই লাইনটি একা ভরসাযোগ্য নয়, প্রতিটি R দেখতে হয়। Inheritance-এ M-এর response 6 থেকে 9 হয়েছে: H-কে বাঁচাতে কম জরুরি M একটু দেরি সয়েছে।

৭ · মডিউল ১১ ও ১২ — sensor, control আর IoT protocol (১০টি প্রশ্ন)

যে পর্বগুলো ঝালিয়ে নেবেন · পর্ব ৬৫–৭৫

মডিউল ১১ — sensor, actuator আর control (৪টি প্রশ্ন)

(মাঝারি) বাজারঘরের scale-এ খালি পাল্লা 400 count, 2000 g-এ 1800 count; grams = round((raw − 400) × 2000 ÷ 1400), দাম = (net_g × 6550 + 500) ÷ 1000 পয়সা (পূর্ণসংখ্যার ভাগ)। Tare 0, ADC পড়ল 1715 count. ওজন আর দাম কত?

  • 1878 g, 123.01 টাকা
  • 1879 g, 123.07 টাকা
  • 2450 g, 160.48 টাকা
  • 1879 g, 12.31 টাকা

(মাঝারি) একটি load cell-এর rated output 2 mV/V, excitation 3.3 V. পূর্ণ ভারে bridge-এর output কত, আর G = 1 + 49.4 kΩ ÷ RG সূত্রের instrumentation amplifier-এ RG = 200 Ω দিলে output কত?

  • 6.6 mV, 6.6 mV
  • 2 mV, প্রায় 0.50 V
  • 6.6 mV, প্রায় 1.64 V
  • 6.6 mV, প্রায় 0.33 V

(সহজ) একটি 1.8° (পাকে 200 full step) stepper motor half-step-এ চলছে, সেকেন্ডে 800টি step pulse. শ্যাফট কত rpm-এ ঘোরে?

  • 120 rpm
  • 240 rpm
  • 2 rpm
  • 60 rpm

(মাঝারি) একটি loop-এ শুধু P দিয়ে পরীক্ষায় স্থায়ী দোল আসে Ku = 2.0-তে, দোলের period Pu = 40 s. Ziegler–Nichols-এর closed-loop নিয়মে PID-এর Kp, Ti আর Td কত?

  • Kp = 1.0, Ti = 20 s, Td = 5 s
  • Kp = 1.2, Ti = 40 s, Td = 10 s
  • Kp = 2.0, Ti = 20 s, Td = 5 s
  • Kp = 1.2, Ti = 20 s, Td = 5 s

মডিউল ১২ — IoT-এর network আর protocol (৬টি প্রশ্ন)

(সহজ) একটি gateway-এর store-and-forward queue-তে সর্বোচ্চ ৫টি বার্তা ধরে, আর ভরে গেলে সবচেয়ে পুরোনোটি বাদ দেয়। Link বন্ধ অবস্থায় seq 1 থেকে 8 তৈরি হলো। Link ফিরলে কোনগুলো পাঠানো হবে?

  • 1, 2, 3, 4, 5
  • 4, 5, 6, 7, 8
  • 8, 7, 6, 5, 4
  • 1 থেকে 8, সবগুলো

(মাঝারি) একটি BLE notification-এর ATT অংশ 1B 06 00 2C 01. Temperature characteristic (0x2A6E, signed ১৬ বিট, 0.01 °C একক, little-endian) হলে মান কত?

  • 112.65 °C
  • 0.06 °C
  • 3.00 °C
  • 300 °C

(মাঝারি) LoRa-তে BW 125 kHz রেখে spreading factor SF7 থেকে SF12 করলে একটি symbol-এর সময় কত হয়, আর কত গুণ বাড়ে?

  • 1.024 ms থেকে 32.768 ms, ৩২ গুণ
  • 1.024 ms থেকে প্রায় 1.755 ms, 12/7 গুণ
  • 7 ms থেকে 12 ms
  • 32.768 ms থেকে 1.024 ms, ৩২ গুণ কমে

(কঠিন) MQTT 3.1.1-এ একটি QoS 1 PUBLISH: topic bazarghar/scale/1/weight (24 byte), payload 110 byte. পুরো packet কত byte?

  • 139
  • 138
  • 140
  • 141

(মাঝারি) একটি CoAP উত্তরের code byte 0x45. এর মানে কী?

  • 4.05 Method Not Allowed
  • 2.05 Content
  • 2.04 Changed
  • দশমিক 69, নির্দিষ্ট কোনো অর্থ নেই

(মাঝারি) একটি MQTT 3.1.1 client CONNECT-এ keep-alive 20 s দিয়েছে আর status topic-এ offline Last Will রেখেছে। হঠাৎ বিদ্যুৎ চলে গেল (DISCONNECT বা TCP বন্ধের খবর যায়নি)। Broker সর্বোচ্চ কতক্ষণ পরে Will প্রকাশ করবে, আর নিয়মমতো DISCONNECT পাঠিয়ে গেলে কী হতো?

  • 20 s; DISCONNECT-এও Will প্রকাশ হতো
  • 40 s; Will প্রকাশ হতো না
  • 30 s; Will মুছে যেত, প্রকাশ হতো না
  • 30 s; DISCONNECT-এও Will প্রকাশ হতো
from collections import deque
def div_round(n, d):                   # README-এর div_round, শূন্য থেকে দূরে
    return (n + d // 2) // d if n >= 0 else -((-n + d // 2) // d)
g = div_round((1715 - 400) * 2000, 1400)
print("ওজন", g, "g, দাম", (g * 6550 + 500) // 1000, "পয়সা")
print(f"bridge {2 * 3.3:.1f} mV, G = {1 + 49400 / 200:.0f}, output {6.6e-3 * (1 + 49400 / 200):.3f} V")
print("stepper:", 800 / 400 * 60, "rpm; ZN:", 0.6 * 2.0, 40 / 2, 40 / 8)
q = deque(maxlen=5)
for seq in range(1, 9):
    q.append(seq)
print("store-and-forward:", list(q))
raw = bytes.fromhex("1B 06 00 2C 01")
print("BLE:", int.from_bytes(raw[3:5], "little", signed=True) / 100, "°C")
print(" ".join(f"SF{sf}: {2 ** sf / 125e3 * 1e3:.3f} ms" for sf in (7, 12)))
topic = "bazarghar/scale/1/weight"
payload = ('{"dev":"scale-1","seq":1,"gross_g":1400,"tare_g":150,"net_g":1250,'
           '"rate_paisa_per_kg":6550,"price_paisa":8188}')
def enc_len(n):                        # MQTT-এর remaining length, ৭ বিট করে
    out = bytearray()
    for _ in range(4):
        b, n = n % 128, n // 128
        out.append(b | (0x80 if n else 0))
        if not n:
            return bytes(out)
rl = 2 + len(topic) + 2 + len(payload)
print(len(topic), len(payload), "RL", rl, enc_len(rl).hex(" "), "মোট", 1 + len(enc_len(rl)) + rl)
c = 0x45
print(f"CoAP 0x45 → {c >> 5}.{c & 31:02d}; keep-alive 20 s → {1.5 * 20} s")

আসল আউটপুট:

ওজন 1879 g, দাম 12307 পয়সা
bridge 6.6 mV, G = 248, output 1.637 V
stepper: 120.0 rpm; ZN: 1.2 20.0 5.0
store-and-forward: [4, 5, 6, 7, 8]
BLE: 3.0 °C
SF7: 1.024 ms SF12: 32.768 ms
24 110 RL 138 8a 01 মোট 141
CoAP 0x45 → 2.05; keep-alive 20 s → 30.0 s

MQTT-এর প্রশ্নের payload হুবহু reference README-এর scale-এর JSON, তাই block সেটির দৈর্ঘ্য মেপে 110 পেয়েছে। ওজন-দামের প্রশ্নটি কোর্সের virtual বাজারঘর board-এ আসল scale firmware দিয়েও চালানো হয়েছে, 1879 g-এর বোঝা দিয়ে (সত্যিকারের run, board.py run firmware/build/scale.elf; Clang 22.1.8, ziglang 0.17.1, MIT; Unicorn 2.1.4):

[     0.0729 ms] UART: scale ready: zero=400 counts, span=1400 counts per 2000 g, rate=65.50 Tk/kg
[   300.1026 ms] UART: raw=1030 gross=900 g tare=0 g net=900 g price=58.95 Tk
[   500.1104 ms] UART: raw=1715 gross=1879 g tare=0 g net=1879 g price=123.07 Tk

Board-এর load-cell মডেল raw = 400 + 0.7 × grams, তাই 1879 g থেকে 1715 count আসে, আর firmware সেখান থেকে আবার 1879 g আর 123.07 টাকা বের করে। এটি virtual board-এর ফল, আসল যন্ত্রের মাপ নয়।

৮ · মডিউল ১৩ — security, secure boot আর edge AI (৪টি প্রশ্ন)

যে পর্বগুলো ঝালিয়ে নেবেন · পর্ব ৭৬–৮০

(সহজ) আক্রমণকারী একটি নকল যন্ত্র বানিয়ে scale-1-এর নাম আর পরিচয়ে broker-এ ওজন publish করছে। STRIDE-এর কোন threat, আর কোন নিরাপত্তা-গুণ ভাঙছে?

  • Spoofing; authentication
  • Tampering; integrity
  • Repudiation; non-repudiation
  • Elevation of privilege; authorization

(মাঝারি) SHA-256-এ বার্তার পরে অন্তত ১ byte (0x80) আর ৮ byte-এর দৈর্ঘ্য যোগ হয়, আর পুরোটা ৬৪ byte-এর block-এ ভাগ হয়। 1000 byte-এর একটি firmware image hash করতে কয়টি block লাগে?

  • ১৫টি
  • ১৭টি
  • ১৬টি
  • ১০০০টি

(মাঝারি) একটি যন্ত্রের anti-rollback counter-এ min_version = 7. নিচের কোন image bootloader চালাবে?

  • Version 6, নির্মাতার বৈধ signature, hash ঠিক
  • Version 8, নির্মাতার বৈধ signature, hash ঠিক
  • Version 9, signature নেই, কিন্তু hash ঠিক
  • Version 8, বৈধ signature, কিন্তু hash মেলে না

(কঠিন) Calibration-এ একটি activation-এর পাল্লা −2.0 থেকে 6.0. Asymmetric int8-এ (−128 থেকে 127) s = (rmax − rmin) ÷ 255 আর z = round(−128 − rmin ÷ s). s আর z কত?

  • s ≈ 0.0314, z = −128
  • s ≈ 0.0235, z = −43
  • s ≈ 0.0314, z = 64
  • s ≈ 0.0314, z = −64
import hashlib

image = bytes(1000)                    # 1000 byte-এর একটি নমুনা image
pad = (64 - (len(image) + 9) % 64) % 64
print("block:", (len(image) + 9 + pad) // 64, "| digest", hashlib.sha256(image).hexdigest()[:16], "…")

def accept(ver, sig_ok, hash_ok, min_ver=7):
    return sig_ok and hash_ok and ver >= min_ver

for img in ((6, True, True), (8, True, True), (9, False, True), (8, True, False)):
    print("version, সই, hash =", img, "→", "চালাবে" if accept(*img) else "বাতিল")
rmin, rmax = -2.0, 6.0
s = (rmax - rmin) / 255
z = round(-128 - rmin / s)
print(f"s = {s:.5f}, z = {z}; 0.0 → {round(0.0 / s) + z}, 6.0 → {round(6.0 / s) + z}, −2.0 → {round(-2.0 / s) + z}")
stride = {"S": "authentication", "T": "integrity", "R": "non-repudiation",
          "I": "confidentiality", "D": "availability", "E": "authorization"}
print("নকল scale-1 → Spoofing → ভাঙে", stride["S"])

আসল আউটপুট:

block: 16 | digest 541b3e9daa09b20b …
version, সই, hash = (6, True, True) → বাতিল
version, সই, hash = (8, True, True) → চালাবে
version, সই, hash = (9, False, True) → বাতিল
version, সই, hash = (8, True, False) → বাতিল
s = 0.03137, z = -64; 0.0 → -64, 6.0 → 127, −2.0 → -128
নকল scale-1 → Spoofing → ভাঙে authentication

শূন্য-ভরা 1000 byte-এর image-এর digest শুধু দেখায় যে hashlib সত্যিই চলেছে। accept ফাংশনের তিনটি শর্ত একসঙ্গে লাগে: সই, hash আর version; একটি বাদ পড়লেই image বাতিল। Quantization-এর শেষ লাইন দেখায় পাল্লার দুই প্রান্ত −128 আর 127-এ পড়েছে, পুরো grid কাজে লেগেছে।

৯ · মিশ্র মহড়া — ঘড়ি ধরে ১০টি প্রশ্ন, সব মডিউল থেকে

সব ভাগ শেষ হলে এই অংশটি একটি ছোট মহড়া পরীক্ষা হিসেবে করুন। প্রশ্নগুলো ইচ্ছা করে এলোমেলো, কারণ আসল পরীক্ষায় 8085-এর flag-এর পরেই RTOS, তারপর ADC আসতে পারে। ওপরের প্রশ্ন থেকে এগুলো আলাদা।

মহড়ার নিয়ম · ১০টি প্রশ্ন, ১৫ মিনিট
  • ঘড়ি ধরুন: ১৫ মিনিটের টাইমার চালু করুন; প্রতি প্রশ্নে গড়ে দেড় মিনিট।
  • আগে খাতায়: ১ থেকে ১০ নম্বরের পাশে অপশন আর এক লাইনের কারণ লিখুন; সময় শেষ হলে তবেই অপশন চাপুন।
  • ফল পড়ুন এভাবে: ৮ বা বেশি ঠিক হলে প্রস্তুতি ভালো; ৫ থেকে ৭ হলে ভুল প্রশ্নের পর্বগুলো ঝালিয়ে নিন; ৪ বা কম হলে আগে মডিউলের ভাগগুলো আবার করুন। এই সীমা শুধু অনুশীলনের সুবিধার জন্য ধরা, কোনো পরীক্ষার মান নয়।

(সহজ) একটি little-endian CPU ঠিকানা 3000H থেকে ১৬ বিটের 1A2BH রাখল। 3000H আর 3001H-এ কী থাকবে?

  • 1AH আর 2BH
  • 1A2BH একটিই ঘরে, 3001H খালি
  • 2BH আর 1AH
  • B2H আর A1H

(সহজ) 8085-এ MVI A,05H তারপর SUI 07H. A, CY আর S কী?

  • A = FEH, CY = 1, S = 1
  • A = FEH, CY = 0, S = 1
  • A = 02H, CY = 1, S = 0
  • A = FDH, CY = 1, S = 1

(মাঝারি) Reset-এর পরে 8085, 8086 আর Cortex-M3 প্রথম instruction কোথা থেকে আনে?

  • তিনটিই 0000H থেকে
  • 0000H; 00000H; 0x00000000
  • 0000H; FFFF0H; vector table-এর প্রথম word-এর ঠিকানা
  • 0000H; FFFF0H; vector table-এর দ্বিতীয় word-এ রাখা ঠিকানা

(মাঝারি) একটি common-cathode 7-segment-এ segment a থেকে g যথাক্রমে D0 থেকে D6-এ, dp D7-এ (নেভা থাকবে)। অঙ্ক 3 দেখাতে কোন byte পাঠাবেন?

  • B0H
  • 4FH
  • 5BH
  • 3FH

(মাঝারি) ৩২ বিটের int-এর একটি microcontroller-এ uint8_t a = 200, b = 100; লেখার পরে if (a + b > 255) কী করে, আর uint8_t c = a + b;-এ c কত?

  • শর্ত মিথ্যা; c = 44
  • শর্ত সত্য; c = 300
  • শর্ত সত্য; c = 44
  • Compile error

(মাঝারি) একটি ৮ বিটের MCU-তে একটি ISR ৩২ বিটের ms counter বাড়ায়, আর main সেটি চারটি আলাদা byte-load-এ পড়ে, নিচের byte আগে। Counter 0x000100FF থেকে 0x00010100 হওয়ার মুহূর্তে main মাঝে মাঝে 0x000101FF পায়। কারণ আর সমাধান কী?

  • Torn read; critical section বা দুবার পড়ে মেলানো
  • volatile নেই, তাই compiler মান cache করে; volatile দিলেই সমাধান
  • Stack overflow; stack বড় করা
  • ADC-র noise; গড় নেওয়া

(মাঝারি) একটি load cell-এর সংকেতে 50 Hz-এর mains hum মিশে আছে, আর firmware 60 Hz-এ নমুনা নেয় (কোনো anti-aliasing filter নেই)। নমুনায় hum কোন frequency-তে দেখা দেবে?

  • 50 Hz
  • 110 Hz
  • 0 Hz, অর্থাৎ স্থির offset
  • 10 Hz

(মাঝারি) একটি counting semaphore-এর শুরুর মান 0, সর্বোচ্চ 2. একটি ISR দ্রুত পরপর তিনবার give করে, অপেক্ষারত task তখনো চলেনি। নতুন give ছাড়া task কয়বার take করে সফল হবে?

  • ৩ বার
  • ২ বার
  • ১ বার
  • ০ বার

(মাঝারি) প্রতি 10 ms-এ একটি নমুনা, আর output শেষ ১৬টি নমুনার moving average. Output বর্তমান থেকে প্রায় কত পিছিয়ে থাকে?

  • 160 ms
  • 80 ms
  • 75 ms
  • 10 ms

(মাঝারি) একটি bootloader image-এর হিসাব করা digest প্রত্যাশিত মানের সঙ্গে memcmp দিয়ে মেলায়, যা প্রথম অমিলেই থামে। এতে কী ঝুঁকি, আর প্রতিকার কী?

  • সময় থেকে কতগুলো শুরুর byte মিলেছে তা ফাঁস হয়; constant-time তুলনা
  • memcmp ধীর, তাই boot দেরি হয়; দ্রুত loop
  • memcmp ঋণাত্মক byte ভুল তুলনা করে; cast করা
  • কোনো ঝুঁকি নেই; কিছু করার দরকার নেই
v = 0x1A2B
print(f"little-endian: 3000H = {v & 0xFF:02X}H, 3001H = {v >> 8:02X}H")
a = (0x05 - 0x07) & 0xFF
print(f"05H − 07H = {a:02X}H, CY (borrow) = {int(0x05 < 0x07)}, S = {a >> 7}")
seg = {"a": 0, "b": 1, "c": 2, "d": 3, "e": 4, "f": 5, "g": 6}

def code(s):
    return sum(1 << seg[x] for x in s)

print(f"CC '3' = {code('abcdg'):02X}H, CA '3' = {~code('abcdg') & 0xFF:02X}H, "
      f"CC '2' = {code('abdeg'):02X}H, CC '0' = {code('abcdef'):02X}H")
a8, b8 = 200, 100                      # C-তে int-এ ওঠে
print("promotion:", a8 + b8 > 255, "| uint8_t-এ রাখলে", (a8 + b8) & 0xFF)
old, new = 0x000100FF, 0x00010100      # নিচের byte পুরোনো, বাকিগুলো নতুন
print(f"ছেঁড়া পড়া = {(new & 0xFFFFFF00) | (old & 0xFF):#010x}")
fs, f = 60, 50
print("alias:", abs(f - round(f / fs) * fs), "Hz")
count, mx, ok = 0, 2, 0
for _ in range(3):                     # ISR-এর তিনটি give
    count = min(count + 1, mx)
for _ in range(3):                     # task-এর তিনটি take
    if count:
        count -= 1
        ok += 1
print("semaphore take সফল:", ok)
print("moving average-এর দেরি:", (16 - 1) / 2 * 10, "ms")

আসল আউটপুট:

little-endian: 3000H = 2BH, 3001H = 1AH
05H − 07H = FEH, CY (borrow) = 1, S = 1
CC '3' = 4FH, CA '3' = B0H, CC '2' = 5BH, CC '0' = 3FH
promotion: True | uint8_t-এ রাখলে 44
ছেঁড়া পড়া = 0x000101ff
alias: 10 Hz
semaphore take সফল: 2
moving average-এর দেরি: 75.0 ms

ছেঁড়া পড়ার লাইন দেখায় নিচের byte পুরোনো (FF) আর বাকি তিনটি নতুন হলে ঠিক প্রশ্নের অস্বাভাবিক মানটি আসে। SUI-এর প্রশ্নটি কোর্সের simulator-এও চালানো (সত্যিকারের run): A=FE … Flags: S=1 Z=0 AC=0 P=0 CY=1 (F=81H).

AI-এর যুগে — AI দিয়ে আরও MCQ বানান, কিন্তু উত্তর নিজে চালিয়ে দেখুন

AI assistant মুহূর্তে শত শত প্রশ্ন বানাতে পারে, কিন্তু এই বিষয়ে সে প্রায়ই 8085 আর 8086 (বা Z80)-এর নির্দেশ আর flag গুলিয়ে ফেলে, ভুল T-state বা cycle গোনে, একটি নির্দিষ্ট microcontroller-এর register-এর নাম আর ঠিকানা বানিয়ে বলে, ISR-এ volatile বা atomic-এর কথা ভুলে যায়, I2C/SPI-এর mode আর baud rate-এর হিসাব ভুল করে, ISR-এ blocking ফাংশন ডাকে, RTOS-এর API ভুল ব্যবহার করে, আর IoT-তে অনিরাপদ default (password লেখা firmware, TLS ছাড়া, সইহীন update) সুপারিশ করে। তাই AI-এর প্রশ্ন অনুশীলনের কাঁচামাল, উত্তরপত্র নয়।

AI-এর প্রচলিত ভুলউদাহরণকীভাবে ধরবেন
CPU গুলিয়ে ফেলা“8085-এর ADD-এর পরে OF দেখুন”Simulator-এ চালিয়ে flag byte দেখুন
ভুল T-state“INX H ৪ T”Intel-এর টেবিল আর simulator-এর T-state মেলান
বানানো registerঅস্তিত্বহীন বিট বা ঠিকানাReference manual-এর register map খুলে মেলান
“+১” বাদ“f = clock ÷ (PSC × ARR)”দুটি মান বসিয়ে হাতে হিসাব, তারপর একটি block-এ
বানানো উৎস“অমুক পরীক্ষায় এসেছিল”উৎস দেখাতে না পারলে দাবি বাদ

নিচের প্রম্পটটি AI-কে প্রশ্ন বানাতে বলে, আর যাচাইয়ের উপায়ও চায়। উত্তর পেলে 8085-এর প্রতিটি দাবি simulator-এ, 8086-এর দাবি NASM আর runner-এ, আর register-এর দাবি datasheet বা reference manual-এ মিলিয়ে নিন।

আমি Microprocessors, Embedded Systems আর IoT-এর MCQ পরীক্ষার প্রস্তুতি নিচ্ছি। বিষয়: [যেমন: 8085-এর flag / 8086-এর addressing / 8255 control word / timer PSC-ARR / UART BRR / RTOS RTA / MQTT QoS] কঠিনতা: [সহজ / মাঝারি / কঠিন] ৮টি MCQ বানাও। প্রতিটির জন্য: ১. ঠিক ৪টি অপশন, শুধু একটি সঠিক। দরকারি সংখ্যা আর কোড প্রশ্নেই থাকবে। ২. কোন CPU বা chip-এর কথা (8085, 8086, STM32F103, ATmega328P …) আর clock কত, তা স্পষ্ট লেখো। ৩. হিসাবের প্রশ্নে সূত্র আর প্রতিটি ধাপ দেখাও, যাতে আমি simulator বা হাতে মিলিয়ে নিতে পারি। ৪. প্রতিটি ভুল অপশন কোন ভুল ধারণা থেকে আসে, এক লাইনে লেখো। ৫. নিশ্চিত না হলে "নিশ্চিত নই" লেখো; কোনো প্রশ্নকে কোনো নির্দিষ্ট পরীক্ষার আসল প্রশ্ন বলে দাবি করবে না।

যাচাইয়ের চেকলিস্ট

কেন এই উত্তর ভুল? — রিভিশনের কৌশল আর বড় ধারণা

আগে নিজে ভাবুন, তারপর খুলে দেখুন।

প্র ০১Flag-এর প্রশ্নে CPU-র নাম কেন উত্তরের অংশ?

কারণ একই বিয়োগ, একই যোগ ভিন্ন CPU-তে ভিন্ন flag বসায়, আর flag-এর নামও এক নয়। 8085-এ flag মাত্র পাঁচটি: S, Z, AC, P, CY; কোনো overflow flag নেই। 8086-এ এর সঙ্গে OF, আর নিয়ন্ত্রণের DF, IF, TF. ARM Cortex-M-এ N, Z, C, V, আর বিয়োগের পরে C-এর অর্থ উল্টো: C = 1 মানে borrow হয়নি।

  • ইতিহাস: Intel 8085 এসেছিল ১৯৭৬ সালে, 8080-এর তিনটি supply-এর বদলে একটি +5 V নিয়ে; 8086 ১৯৭৮ সালে ১৬ বিট আর segment নিয়ে, তখনই OF যুক্ত হয় (পর্ব ০২, ১৪)। ARM-এর জন্ম Acorn-এ, ১৯৮৫ সালের প্রথম chip থেকে (পর্ব ২৮)।
  • Borrow-এর দুই রীতি: 8085 বিয়োগকে A + (NOT operand) + 1 হিসেবে করে, কিন্তু CY-তে উল্টো করে borrow রাখে (Spec decision 4); ARM সেই যোগের carry-ই সরাসরি C-তে রাখে (পর্ব ০৫)।
  • AC কেন: AC শুধু DAA-র জন্য; নিচের nibble থেকে carry হলে DAA বোঝে 06H যোগ করতে হবে (পর্ব ১১)।

রিভিশনে প্রতিটি flag-এর প্রশ্নের পাশে তিনটি প্রশ্ন লিখুন: কোন CPU, কোন নির্দেশ কোন flag ছোঁয়, আর unsigned না signed অর্থে প্রশ্ন। INR আর DCR CY ছোঁয় না, INX আর DCX কোনো flag-ই না; MVI, MOV, LDA-র মতো data transfer flag অক্ষত রাখে। এই “কে ছোঁয় না” তালিকা অনেক distractor কেটে দেয়। আর signed প্রশ্নে 8085-এ নিজে overflow দেখতে হয়: দুটি একই চিহ্নের সংখ্যা যোগে ফলের চিহ্ন উল্টে গেলে overflow, যা কোনো flag বলবে না।

মূল উপলব্ধি: flag একটি CPU-র নিজস্ব ভাষা; প্রশ্নের প্রথম শব্দ (8085, 8086, Cortex-M) না পড়ে উত্তর দেওয়া মানে অন্য ভাষায় উত্তর।

প্র ০২“+১” আর “−১” এত distractor কেন বানায়, আর কীভাবে মনে রাখবেন?

কারণ hardware গোনে শূন্য থেকে, আর মানুষ গোনে এক থেকে। Timer-এর prescaler 0 মানে ১ দিয়ে ভাগ, ARR 999 মানে ১০০০টি ধাপ, SysTick-এর LOAD 7999 মানে ৮০০০টি cycle. উল্টো দিকে, 8237-এ ২৫৬টি byte সরাতে count-এ 255 লিখতে হয়, আর memory-র শেষ ঠিকানা = শুরু + মাপ − ১।

  • নথির ভাষা: STM32-এর reference manual RM0008 timer-এর clock-কে PSC + 1 দিয়ে ভাগ বলে; ARMv7-M-এর SysTick-এর period LOAD + 1 (পর্ব ৪৪, ০৬)। Intel-এর 8237A-র datasheet বলে transfer-এর সংখ্যা লেখা মানের চেয়ে এক বেশি (পর্ব ২৭)।
  • 8254-এর ধাঁধা: mode 0-এ count N লিখলে OUT ওঠে N + 1 pulse পরে, কারণ প্রথম pulse শুধু load করে (পর্ব ২৫)।
  • Delay loop: 14N + 4-এর “+4” আসে MVI-এর ৭ T আর শেষ JNZ-এর না-লাফানো ৩ T কম থেকে (পর্ব ১২)।

খাতায় অভ্যাস করুন: সূত্র লেখার আগে সবচেয়ে ছোট মান বসান। ARR = 0 হলে কয়টি ধাপ? একটি, তাই সূত্রে ARR + 1. PSC = 0 হলে clock অপরিবর্তিত, তাই PSC + 1. মেমরির ক্ষেত্রে 1 byte-এর chip 4000H-এ বসালে শেষ ঠিকানাও 4000H, তাই “− ১” বোঝা যায়। একটি ছোট উদাহরণে সূত্র মিললে বড় সংখ্যাতেও মিলবে। PSC/ARR-এর প্রশ্নে চারটি অপশনের অন্তত একটি প্রায় সবসময় “+১” বাদ দেওয়া ফল, যেমন ৫০ Hz-এর বদলে 49.31 Hz.

মূল উপলব্ধি: register-এর মান আর বাস্তবের সংখ্যা এক নয়; শূন্য থেকে গোনা hardware-এর ভাষা মনে রাখলে “+১” আর ভুল হয় না।

প্র ০৩Priority-র প্রশ্নে “ছোট সংখ্যা না বড় সংখ্যা জরুরি” কেন আলাদা করে জিজ্ঞেস করতে হয়?

কারণ জনপ্রিয় তিনটি ব্যবস্থা তিন রকম কথা বলে। Cortex-M-এর NVIC-এ ছোট সংখ্যা বেশি জরুরি, priority 0 সবচেয়ে উঁচু configurable স্তর। FreeRTOS-এ উল্টো: বড় সংখ্যা বেশি জরুরি, idle task 0-তে। কোর্সের RTOS simulator FreeRTOS-এর রীতি মানে (Spec decision 32). আর 8085-এ priority স্থির: TRAP, তারপর RST 7.5, 6.5, 5.5, শেষে INTR (Spec decision 7).

  • ইতিহাস: ARM-এর Cortex-M3 (প্রায় ২০০৪–০৫) NVIC-কে core-এর অংশ করে, যাতে সব নির্মাতার chip-এ interrupt-এর নিয়ম এক থাকে (পর্ব ৩০)। ১৯৯৭ সালে Mars Pathfinder-এর বারবার reset-এর প্রকাশিত ব্যাখ্যা priority inversion, আর সমাধান ছিল mutex-এ priority inheritance (পর্ব ৫৭)।
  • 8259-এর রীতি: fully nested mode-এ IR0 সবচেয়ে উঁচু, আর non-specific EOI সবচেয়ে উঁচু চলমান বিটটি মোছে (পর্ব ২৬)।
  • সমান priority: NVIC-এ সমান priority কখনো preempt করে না; অপেক্ষা করে আর tail-chain করে (পর্ব ৩০)।

প্রশ্নে priority দেখলে প্রথমে লিখুন কার নিয়ম: NVIC, RTOS, না পুরোনো chip. তারপর তীর আঁকুন, কোনটি কাকে থামাতে পারে। RTOS-এর প্রশ্নে rate-monotonic নিয়মটিও দিকনির্ভর: period যত ছোট, priority তত বেশি জরুরি, সংখ্যাটা যেভাবেই লেখা হোক। FreeRTOS firmware-এর ভেতরে NVIC-এর সংখ্যা আর task-এর সংখ্যা পাশাপাশি থাকে, তাই এই দুই উল্টো রীতি একই কোডে মেশে; AI assistant-ও প্রায়ই এখানে গুলিয়ে ফেলে।

মূল উপলব্ধি: priority একটি সংখ্যা নয়, একটি নিয়মের অংশ; নিয়মের মালিক কে, সেটি আগে জানুন।

প্র ০৪volatile দিলেই ISR আর main-এর ভাগ করা data নিরাপদ নয় কেন?

volatile compiler-কে একটি প্রতিশ্রুতি দেয়: প্রতিটি পড়া আর লেখা সত্যিই ঘটবে, লেখা মাপে আর লেখা ক্রমে। কিন্তু একাধিক নির্দেশের একটি কাজকে এক মুহূর্তের কাজ বানায় না। count++ Cortex-M-এ load, যোগ আর store, তিনটি নির্দেশ; মাঝে ISR এলে তার যোগ হারায়। ৮ বিটের MCU-তে ৩২ বিটের counter পড়া চারটি load; মাঝে carry ছড়ালে মেশানো মান আসে।

  • ইতিহাস: volatile এসেছিল ১৯৮৯ সালের ANSI C মানদণ্ডে, hardware register আর একই মেমরি ভাগ করা কোডের জন্য; atomic অপারেশনের মানক রূপ _Atomic আসে অনেক পরে, C11-এ (পর্ব ৩৪)।
  • কোর্সের run: বাজারঘর board-এ main আর ISR দুজনেই একটি volatile counter বাড়ালে ৩৪৪০টি ISR-যোগের ২২৮৪টি হারিয়েছে (পর্ব ৩৪)।
  • Hardware-এর সমাধান: GPIO-তে BSRR-এর মতো set/reset register এক store-এ বিট বদলায়, পড়া ছাড়া, তাই অন্য বিট অক্ষত (পর্ব ৩৫)।

MCQ-তে দুটি আলাদা প্রশ্ন আলাদা রাখুন। প্রথম: compiler কি পড়াটি বাদ দিতে পারে? তাহলে volatile লাগে, যেমন ISR-এর flag-এর অপেক্ষার loop. দ্বিতীয়: কাজটি কি একাধিক নির্দেশের, আর মাঝে অন্য কেউ ঢুকতে পারে? তাহলে critical section, atomic নির্দেশ, set/reset register, বা এক লেখক এক পাঠকের ring buffer লাগে। যে অপশন বলে “volatile দিলেই race শেষ”, সেটি প্রায়ই distractor. উল্টো দিকে, যে অপশন volatile-কে পুরো বাদ দেয়, সেটিও ভুল, কারণ তখন compiler ISR-এর লেখা flag একবার পড়ে চিরকাল আটকে থাকতে পারে।

মূল উপলব্ধি: volatile দৃশ্যমানতার প্রতিশ্রুতি, অবিভাজ্যতার নয়; দুটি সমস্যার দুটি আলাদা ওষুধ।

প্র ০৫IoT protocol-এর সংখ্যার প্রশ্নে (QoS, keep-alive, byte) মানদণ্ডের বাক্য কেন মুখস্থের চেয়ে ভালো?

কারণ এই প্রশ্নের প্রতিটি সংখ্যা একটি নির্দিষ্ট নিয়মের বাক্য থেকে আসে, আর distractor আসে সেই বাক্যের একটি শব্দ বাদ দিয়ে। MQTT 3.1.1-এ subscriber পায় min(publish-এর QoS, অনুমোদিত QoS); broker সংযোগ ভাঙে keep-alive-এর দেড় গুণ চুপ থাকলে; remaining length ৭ বিট করে লেখা হয়, তাই 127-এর বেশি হলে ২ byte. CoAP-এর code byte-এর ওপরের ৩ বিট class, নিচের ৫ বিট detail.

  • ইতিহাস: MQTT তৈরি করেন Andy Stanford-Clark আর Arlen Nipper, ১৯৯৯ সালে, তেলের পাইপলাইনের দূরের যন্ত্রের জন্য; ২০১৪ সালে MQTT 3.1.1 OASIS মানদণ্ড হয় (পর্ব ৭৩)। CoAP-এর মূল মানদণ্ড RFC 7252, ২০১৪ সালে প্রকাশিত (পর্ব ৭৪)।
  • কোর্সের lab: reference lab-এর MQTT demo-তে amqtt broker-এর দুটি বিচ্যুতি পাওয়া গিয়েছিল, যার একটি ঠিক এই min(QoS) নিয়ম; তাই lab সেগুলো runtime-এ ঠিক করে (Spec decision 37).
  • Last Will: নিয়মমতো DISCONNECT Will মুছে দেয়; Will আসে শুধু অস্বাভাবিক বিচ্ছেদে (পর্ব ৭৫)।

রিভিশনে প্রতিটি protocol-এর জন্য একটি ছোট কার্ড বানান: packet-এর গঠন, ঘড়ির নিয়ম (keep-alive, retransmit), আর একটি সংখ্যার উদাহরণ নিজে হিসাব করা, যেমন বাজারঘরের scale-এর ১১০ byte payload-এর QoS 1 PUBLISH 141 byte. আসল tool-এ যাচাই করা আরও ভালো: কোর্সের lab-এ paho-mqtt আর aiocoap-এর packet log দেখা যায়। এক broker-এর আচরণ দেখে নিয়ম ধরে নেবেন না; lab-এর অভিজ্ঞতাই দেখায়, জনপ্রিয় বাস্তবায়নও মানদণ্ড থেকে সরে যেতে পারে।

মূল উপলব্ধি: protocol-এর প্রশ্নের উত্তর মানদণ্ডের একটি বাক্য; বাক্যটি মনে রাখলে সংখ্যা নিজেই আসে।

শেষ ধাপ — ক্রম সাজান আর স্কোর দেখুন

উপরের সব MCQ শেষ করলে নিচে আপনার মোট স্কোর দেখাবে।

ক্রমবাজারঘরের smart scale-এ ওজন থেকে dashboard পর্যন্ত ছয়টি ধাপ। আগে থেকে পরে সাজান (▲▼ চেপে সরান)

  1. Load cell-এর bridge ওজনকে কয়েক mV-এ বদলায়
  2. Instrumentation amplifier পার্থক্যটি বড় করে
  3. ১২ বিটের ADC voltage-কে count-এ আনে
  4. Firmware zero বিয়োগ করে calibration দিয়ে গ্রাম বের করে
  5. দাম পয়সায় হিসাব হয়: (net_g × 6550 + 500) ÷ 1000
  6. MQTT-তে bazarghar/scale/1/weight-এ QoS 1, retained-এ পাঠানো হয়

শব্দকোষ

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

মনে রাখুন

  1. CPU আগে: 8085, 8086 আর Cortex-M-এর flag, borrow আর priority-র নিয়ম আলাদা; প্রশ্নের প্রথম শব্দটি পড়ুন।
  2. একক আর “+১”: crystal ÷ 2 = 8085-এর clock; PSC, ARR আর LOAD-এ +১; শেষ ঠিকানা = শুরু + মাপ − ১।
  3. বিটের ছক: control word, CRL, BRR আর mode word-এ প্রতিটি ঘর আলাদা ভরুন, তারপর hex.
  4. volatile আর atomic আলাদা: পড়া নিশ্চিত করা এক কথা, কাজ অবিভাজ্য রাখা আরেক কথা।
  5. মানদণ্ডের বাক্য: QoS-এর min, keep-alive-এর দেড় গুণ, remaining length-এর ৭ বিট, hash বনাম signature.

পরের পর্বে: পর্ব ৮৩ “লিখিত ও মৌখিক (ভাইভা) প্রশ্ন — মাইক্রোপ্রসেসর, এমবেডেড সিস্টেম ও IoT”: MCQ চেনায় কোনটি সঠিক, লিখিত পরীক্ষা আর ভাইভা চায় কেন সঠিক; সেখানে তুলনা আর ব্যাখ্যার আদর্শ উত্তর।

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

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