এই পর্বে যা শিখবেন
- Clock tree থেকে SysTick-এর LOAD, timer-এর PSC/ARR, PWM-এর duty ও resolution আর UART-এর BRR ও ভুলের শতাংশ বের করা
- ADC count থেকে গ্রাম, দাম আর °C; bridge-এর gain, DAC-এর output, RC filter আর I2C pull-up-এর জানালা হিসাব করা
- Q-format-এর গুণ, স্কেলের Q-gain আর call graph থেকে stack-এর আকার; CAN-এর বিট গোনা আর Modbus-এর CRC হাতে চালানো
- Utilization, Liu–Layland সীমা, response-time analysis আর queue-র গভীরতা দিয়ে schedule প্রমাণ করা
- গড় current, battery-র আয়ু, MTBF, availability, filter-এর output, একটি PID ধাপ, LoRa-র airtime, MQTT-এর byte আর int8-এর scale বের করা
১ · পাতার নিয়ম, ভাগের মানচিত্র আর উত্তরের পাঁচ ধাপ
বাজারঘরের দোকানি দিন শেষে খাতা মেলান: কত কেজি আলু, কেজিপ্রতি কত, মোট কত টাকা, আর একটি পয়সাও এদিক-ওদিক হলে কোথায় ভুল, খুঁজে বের করেন। এমবেডেড নকশার গাণিতিক প্রশ্নও এমন খাতা: clock কত, কয়টি count, কোন একক, কোথায় গোল করা হলো। এখানে প্রতিটি প্রশ্ন নিজে-নিজে সম্পূর্ণ: যা data লাগে, প্রশ্নেই দেওয়া। Microcontroller-এর অংশ বলে hex লেখা হয়েছে C-এর রীতিতে (0x45), আর একক SI-তে, সংখ্যার পরে ফাঁক রেখে (8 MHz, 3.3 V, 4.7 kΩ)।
- Data আর একক: clock কোন bus-এর, সময় ms না µs, current mA না µA, আর কোনটি “ধরা মান” (datasheet-এর নয়)।
- সূত্র: কোন পর্বের কোন সূত্র, এক লাইনে লিখুন। পরীক্ষক সূত্র দেখেই অর্ধেক নম্বর দেন।
- একক নিয়ে হিসাব: mA × ms = µC, uA·s ÷ s = uA; একক না মিললে ভুল সেখানেই।
- Integer আর সীমা: register কয় বিট (SysTick ২৪, timer-এর PSC/ARR ১৬), “−1”, গোল করার নিয়ম আর overflow.
- মেলানো: প্রতিটি অংশের শেষে একটি Python চেকার; চালিয়ে নিজের খাতার সঙ্গে মেলান।
ছবি ৮৪.১ — কোন অংশে কোন ধরনের হিসাব, আর মূল পর্ব
নীল microcontroller-এর peripheral, সবুজ analog আর সংখ্যা, বেগুনি bus আর RTOS, কমলা system আর IoT
কোন tool কী দেয়: পাতার Python block-গুলো পর্বগুলোর নিজের সূত্র আর ফাংশন (CAN-এর crc15, Modbus-এর crc16, LoRa-র airtime_ms, MQTT-এর rem_len হুবহু কপি)। “সত্যিকারের run” লেখা অংশ এসেছে কোর্সের reference lab থেকে: বাজারঘর board (board.py, Unicorn 2.1.4-এ virtual Cortex-M3, firmware Clang 22.1.8; board-টি আসল কোনো product নয়, কোর্সের নিজের মডেল), rtos_sim.py, আর ziglang 0.17.1-এর Clang দিয়ে host-এ compile করা একটি ছোট C program. Board-এ 1 নির্দেশ = 1 cycle আর UART-এর সময় মাপা হয় না (Spec decision ১৭ আর ২৪), তাই আসল chip-এর সময় এখানে সূত্র আর datasheet থেকে।
| অংশ | প্রশ্নের ধরন | মূল পর্ব | প্রশ্ন |
|---|---|---|---|
| ২ | Clock tree, SysTick-এর LOAD, PSC/ARR, PWM | ৩৩, ৪৪, ৪৫ | ২.১–২.৪ |
| ৩ | UART-এর সময়, BRR আর ভুল %, I2C pull-up আর frame | ৪৯, ৫১ | ৩.১–৩.৪ |
| ৪ | ADC থেকে গ্রাম আর দাম, bridge-এর gain, °C, DAC, RC filter | ৪৭, ৪৮, ৬৫, ৬৬ | ৪.১–৪.৬ |
| ৫ | Q-format, q15 গুণ, Q-gain, stack-এর আকার | ৩৯, ৪০ | ৫.১–৫.৪ |
| ৬ | CAN-এর বিট আর সময়, bus-off, Modbus CRC-16 | ৫২, ৫৩ | ৬.১–৬.৩ |
| ৭ | U, Liu–Layland, RTA, queue-র গভীরতা | ৫৪, ৫৬, ৫৮ | ৭.১–৭.৩ |
| ৮ | গড় current, battery-র আয়ু, MTBF, availability, TMR | ৬০, ৬২, ৬৩ | ৮.১–৮.৩ |
| ৯ | Moving average, EMA, median, Kalman gain, PID | ৬৮, ৬৯ | ৯.১–৯.৩ |
| ১০ | LoRa-র airtime আর link budget, MQTT/CoAP-এর byte, int8 | ৭২–৭৪, ৭৮ | ১০.১–১০.৪ |
8085 আর 8086-এর program, delay আর interfacing-এর সমস্যা আছে পর্ব ৮১-এ; তুলনামূলক লিখিত প্রশ্ন পর্ব ৮৩-এ, আর হাতে কোড লেখার ইন্টারভিউ-প্রশ্ন পর্ব ৮৫-এ। এখানে সেগুলো আবার নেই।
২ · Clock, SysTick, timer আর PWM
ঝালিয়ে নিন: পর্ব ৩৩ · Clock, reset আর power domain (clock tree, PLL, STM32F103-এর সীমা), পর্ব ৪৪ · Timer আর counter (fUEV = fTIM ÷ ((PSC + 1)(ARR + 1))), পর্ব ৪৫ · PWM (duty = CCR ÷ (ARR + 1)). SysTick-এর period = LOAD + 1 cycle, LOAD ২৪ বিটের।
২.১STM32F103-এ HSE 8 MHz, PLL ×9, AHB ÷1, APB1 ÷2, APB2 ÷1, ADC prescaler ÷6. SYSCLK, PCLK1, TIM2-এর clock, ADC clock আর flash wait state কত? APB1 ÷1 বা ADC ÷4 দিলে কোন সীমা ভাঙে (PCLK1 ≤ 36 MHz, ADC ≤ 14 MHz)? — ৫ নম্বর (সহজ)
SYSCLK = 8 × 9 = 72 MHz, HCLK একই। PCLK1 = 72 ÷ 2 = 36 MHz. APB1-এর ভাগ 1 না হলে timer পায় দ্বিগুণ: TIM2 = 72 MHz. ADC = 72 ÷ 6 = 12 MHz. 48 MHz-এর ওপরে flash-এ ২টি wait state, আর সেটি বসাতে হয় গতি বাড়ানোর আগে। APB1 ÷1 দিলে PCLK1 = 72 MHz (সীমা 36), ADC ÷4 দিলে 18 MHz (সীমা 14).
নম্বর-ভাগ: চারটি clock (৩), wait state (১), সীমা (১)। যেখানে নম্বর কাটে: TIM2-কে 36 MHz ধরা; ×2-এর নিয়ম ভুললে timer-এর প্রতিটি হিসাব অর্ধেক সরে যায়।
২.২(ক) বাজারঘর board (8 MHz)-এ 1 ms আর 10 ms-এর tick-এর SysTick LOAD কত? (খ) কেউ 1 ms-এর জন্য LOAD = 8000 লিখল: দিনে ঘড়ি কত সরে? (গ) 72 MHz-এর STM32F103-এ core clock থেকে 250 ms-এর একটি tick সম্ভব? না হলে উপায়? — ৫ নম্বর (সহজ)
(ক) period = LOAD + 1 cycle, তাই LOAD = f × t − 1: 1 ms-এ 7999, 10 ms-এ 79999 (README-র cold room-এর tick, Spec decision ২২)। (খ) প্রতি tick-এ 8001 cycle, অর্থাৎ ৮০০০-এ এক cycle বেশি: দিনে 10.8 s পিছিয়ে পড়ে। (গ) 72 MHz × 0.25 s − 1 = 17,999,999, অথচ ২৪ বিটের সর্বোচ্চ 16,777,215: আঁটে না। উপায়: আসল STM32F103-এ SysTick-এর উৎস HCLK ÷ 8 = 9 MHz নিলে 2,249,999 আঁটে; অথবা 10 ms-এর tick আর software-এ ২৫টি গোনা। (কোর্সের board CLKSOURCE রাখে কিন্তু সবসময় core clock গোনে।)
যেখানে নম্বর কাটে: “−1” বাদ দেওয়া, আর ২৪ বিটের সীমা না দেখা।
২.৩72 MHz-এর TIM2 থেকে (ক) 1 kHz-এর update, প্রতি count 1 µs; (খ) 1 Hz, প্রতি count 100 µs; (গ) 44.1 kHz. প্রতিটির PSC, ARR আর আসল frequency? (ঘ) কেউ 1 kHz-এর জন্য PSC = 0, ARR = 71999 লিখল: কী হয়? — ১০ নম্বর (মাঝারি)
- মোট ভাগ N = fTIM ÷ f = (PSC + 1)(ARR + 1), আর দুটিই ১৬ বিট (0–65535).
- (ক) PSC + 1 = 72 MHz × 1 µs = 72, তাই PSC 71, ARR 999. (খ) PSC + 1 = 7200: PSC 7199, ARR 9999.
- (গ) N = 72,000,000 ÷ 44,100 = 1632.65, পূর্ণসংখ্যায় 1633: PSC 0, ARR 1632, আসল 44090.631 Hz, ভুল −212 ppm. N পূর্ণসংখ্যা নয় বলে কোনো জোড়াই হুবহু মেলে না।
- (ঘ) 71999 ১৬ বিটে আঁটে না। STM32F1-এর ১৬ বিটের timer-এ থাকে নিচের ১৬ বিট, 6463: timer চলে 72 MHz ÷ 6464 = 11138.6 Hz, চাওয়ার এগারো গুণের বেশি।
নম্বর-ভাগ: সূত্র (২), তিনটি জোড়া (৬), ১৬ বিটের যুক্তি (২)। যেখানে নম্বর কাটে: PSC = 72 লেখা (“+1” ভুলে); তখন tick 1.0139 µs.
২.৪TIM3-এর clock 72 MHz, PSC = 71. (ক) বাজারঘরের alarm buzzer 2 kHz, 50 %: ARR আর CCR1? (খ) CCR1 = 125 হলে duty আর 3.3 V-এর গড়? (গ) 50 Hz-এর servo-তে 1.5 ms pulse: ARR আর CCR1? (ঘ) PSC = 0-তে 20 kHz PWM-এর resolution কত বিট? (ঙ) PWM mode 1-এ CCR1 = 0 আর CCR1 > ARR হলে output? — ১০ নম্বর (মাঝারি)
PSC = 71 মানে প্রতি count 1 µs. (ক) 500 µs-এর period: ARR 499, CCR1 250. (খ) 125 ÷ 500 = 25 %, গড় 0.25 × 3.3 = 0.825 V. (গ) 20 ms: ARR 19999, 1500 µs: CCR1 1500 (7.5 %). (ঘ) N = 72 MHz ÷ 20 kHz = 3600 ধাপ: ARR 3599, log2 3600 = 11.81 বিট (PWM resolution). (ঙ) CCR1 = 0: সবসময় 0; CCR1 > ARR: সবসময় 1 (100 %).
যেখানে নম্বর কাটে: duty = CCR ÷ ARR লেখা; ভাগ হবে ARR + 1 দিয়ে, নইলে 100 % কখনো আসে না।
# ২.১–২.৪-এর চেকার: clock tree, SysTick-এর LOAD, PSC/ARR আর PWM (পর্ব ৩৩, ৪৪, ৪৫-এর সূত্র)
import math
HSE, MUL, APB1, ADCPRE = 8e6, 9, 2, 6
sysclk = HSE * MUL
pclk1 = sysclk / APB1
tim2 = pclk1 * (1 if APB1 == 1 else 2) # APB1-এর ভাগ 1 না হলে timer-এ ×2
ws = 0 if sysclk <= 24e6 else 1 if sysclk <= 48e6 else 2
print(f"SYSCLK {sysclk/1e6:.0f} MHz, PCLK1 {pclk1/1e6:.0f}, TIM2 {tim2/1e6:.0f},"
f" ADC {sysclk/ADCPRE/1e6:.0f} MHz, wait state {ws}")
for hz, ms in ((8e6, 1), (8e6, 10), (72e6, 250), (9e6, 250)):
load = int(hz * ms / 1000) - 1
print(f"SysTick {hz/1e6:2.0f} MHz, {ms:3} ms: LOAD = {load:>10,}",
"আঁটে" if load < 2**24 else "২৪ বিটে আঁটে না")
print(f"8 MHz-এ LOAD 8000 লিখলে tick এক cycle লম্বা: দিনে {86400 / 8000:.1f} s পিছিয়ে")
def psc_arr(f_tim, f_out, tick=None):
n = round(f_tim / f_out) # (PSC+1)(ARR+1)
p1 = round(f_tim * tick) if tick else 1 # চাওয়া tick থেকে PSC+1
while n % p1 or n // p1 > 65536:
p1 += 1
return p1 - 1, n // p1 - 1, f_tim / n
for f, tick in ((1000, 1e-6), (1, 1e-4), (44100, None), (2000, 1e-6), (50, 1e-6), (20000, None)):
psc, arr, real = psc_arr(72e6, f, tick)
print(f"{f:>5} Hz: PSC={psc:<4} ARR={arr:<5} ধাপ {arr + 1:<5} ({math.log2(arr + 1):5.2f} বিট)"
f" আসল {real:.3f} Hz ({(real - f) / f * 1e6:+.0f} ppm)")
print("ARR-এ 71999 লিখলে থাকে", 71999 & 0xFFFF, f"-> {72e6 / 6464:.1f} Hz")
print(f"2 kHz, CCR 125: duty {125 / 500:.0%}, গড় {125 / 500 * 3.3:.3f} V; servo 1.5 ms: CCR 1500 = {1500 / 20000:.1%}")আসল আউটপুট (ব্রাউজারের Python):
SYSCLK 72 MHz, PCLK1 36, TIM2 72, ADC 12 MHz, wait state 2
SysTick 8 MHz, 1 ms: LOAD = 7,999 আঁটে
SysTick 8 MHz, 10 ms: LOAD = 79,999 আঁটে
SysTick 72 MHz, 250 ms: LOAD = 17,999,999 ২৪ বিটে আঁটে না
SysTick 9 MHz, 250 ms: LOAD = 2,249,999 আঁটে
8 MHz-এ LOAD 8000 লিখলে tick এক cycle লম্বা: দিনে 10.8 s পিছিয়ে
1000 Hz: PSC=71 ARR=999 ধাপ 1000 ( 9.97 বিট) আসল 1000.000 Hz (+0 ppm)
1 Hz: PSC=7199 ARR=9999 ধাপ 10000 (13.29 বিট) আসল 1.000 Hz (+0 ppm)
44100 Hz: PSC=0 ARR=1632 ধাপ 1633 (10.67 বিট) আসল 44090.631 Hz (-212 ppm)
2000 Hz: PSC=71 ARR=499 ধাপ 500 ( 8.97 বিট) আসল 2000.000 Hz (+0 ppm)
50 Hz: PSC=71 ARR=19999 ধাপ 20000 (14.29 বিট) আসল 50.000 Hz (+0 ppm)
20000 Hz: PSC=0 ARR=3599 ধাপ 3600 (11.81 বিট) আসল 20000.000 Hz (+0 ppm)
ARR-এ 71999 লিখলে থাকে 6463 -> 11138.6 Hz
2 kHz, CCR 125: duty 25%, গড় 0.825 V; servo 1.5 ms: CCR 1500 = 7.5%
প্রথম সারি ২.১, পরের পাঁচ সারি ২.২। PSC/ARR-এর সারিগুলো ২.৩ আর ২.৪-এর উত্তর, প্রতিটির resolution-সহ: 1 kHz-এ ১০০০ ধাপ (9.97 বিট), 20 kHz-এ 3600 ধাপ। একমাত্র অমিল 44.1 kHz-এ, −212 ppm. শেষের আগের লাইন ২.৩(ঘ)-এর ফাঁদ।
৩ · UART আর I2C — সময়, BRR আর pull-up
ঝালিয়ে নিন: পর্ব ৪৯ · UART (8N1 = ১০ বিট; BRR = round(fCK ÷ baud), ১৬ গুণ oversampling, ওপরের ১২ বিট পূর্ণ অংশ আর নিচের ৪ বিট ভগ্নাংশ), পর্ব ৫১ · I2C (Rp(min) = (VDD − VOL) ÷ IOL, Rp(max) = tr ÷ (0.8473 × Cb), NXP UM10204 §7.1).
৩.১9600 আর 115200 baud-এ: এক বিট, 8N1-এ এক byte আর 8E1-এ এক byte-এর সময়, সেকেন্ডে সর্বোচ্চ কত byte, আর smart scale-এর ৬০ byte-এর দামের লাইন (\r\n-সহ) পাঠাতে কত সময়? — ৫ নম্বর (সহজ)
বিট = 1 ÷ baud: 104.17 µs আর 8.68 µs. 8N1-এ start + ৮ data + stop = ১০ বিট: 1041.7 µs আর 86.8 µs; 8E1-এ ১১ বিট: 1145.8 µs আর 95.5 µs. সেকেন্ডে 960 আর 11520 byte. দামের লাইন: 60 × 10 ÷ baud = 62.50 ms আর 5.21 ms. যেখানে নম্বর কাটে: byte = ৮ বিট ধরা; তখন সময় ২০ % কম আসে।
৩.২STM32F1-ধাঁচের UART: fCK 8 MHz, 36 MHz আর 72 MHz-এ 115200 baud-এর BRR, আসল baud আর ভুল %; আর 8 MHz-এ 460800? HSI-তে চলা chip-এ (ঘরের তাপমাত্রাতেই ১–২ % সরতে পারে) 460800 কি নিরাপদ? — ১০ নম্বর (মাঝারি)
- 8 MHz: 8,000,000 ÷ 115200 = 69.44 → 69 = 0x45 = 4 + 5/16; আসল 115942 baud, +0.64 %. কোর্সের board-এর
uart_init()-ও 69 দেয় (board baud-এর সময় মাপে না, Spec decision ২৪)। - 36 MHz: 312.5 → 0x138 (19 + 8/16), +0.16 %. 72 MHz: 625 = 0x271, ভুল 0.
- 8 MHz-এ 460800: 17.36 → 0x11, আসল 470588 baud, +2.12 %.
- আদর্শ সীমা 0.5 ÷ 9.5 = 5.26 %, কিন্তু STM32-এর কিছু reference manual ৮ data বিটে দুই প্রান্ত মিলিয়ে প্রায় 3.75 % দেয়। 2.12 % + HSI-এর ১–২ % = সীমার কাছে বা ওপরে: নিরাপদ নয়। Crystal নিন বা baud কমান।
যেখানে নম্বর কাটে: ভুলের শতাংশ শুধু BRR থেকে ধরা; clock-এর নিজের ভুলও একই বাজেট থেকে খায়।
৩.৩I2C bus, VDD 3.3 V, VOL(max) 0.4 V at 3 mA. (ক) Rp(min)? (খ) Fast mode (400 kHz, tr ≤ 300 ns) bus capacitance 200 pF আর 400 pF-এ Rp(max), আর কোন resistor? (গ) 55 pF-এর bus-এ 4.7 kΩ দিলে tr কত, 400 kHz চলবে? — ১০ নম্বর (মাঝারি)
(ক) (3.3 − 0.4) ÷ 3 mA = 967 Ω: এর চেয়ে ছোট pull-up-কে pin যথেষ্ট নিচে টানতে পারে না। (খ) 300 ns ÷ (0.8473 × 200 pF) = 1770 Ω: জানালা 967–1770 Ω, যেমন 1.5 kΩ (tr = 254 ns). 400 pF-এ Rp(max) = 885 Ω < 967 Ω: জানালা নেই; bus ভাগ, buffer, বা Standard mode (তখন 2951 Ω পর্যন্ত)। (গ) 0.8473 × 4.7 kΩ × 55 pF = 219 ns ≤ 300 ns: চলবে।
যেখানে নম্বর কাটে: tr = RC লেখা; 30 % থেকে 70 %-এ উঠতে লাগে ln(0.7 ÷ 0.3) = 0.8473 RC.
৩.৪TMP102-ধাঁচের sensor (ঠিকানা 0x48)-এর register 0x00 থেকে দুই byte পড়তে তারে কোন byte-গুলো যায়? মোট কত SCL clock, আর 100 kHz ও 400 kHz-এ কত সময়? ঠিকানা 0x49-এ কেউ না থাকলে? — ৫ নম্বর (সহজ)
S, 0x90 (0x48 << 1, W), ACK, 0x00 (pointer), ACK, Sr, 0x91 (R), ACK, MSB (MCU-র ACK), LSB (MCU-র NACK), P. পাঁচ byte × ৯ = ৪৫টি clock: 450 µs আর 112.5 µs (START/STOP-এর সময় বাদে)। 0x49: 0x92-এর পরে NACK, ৯টি clock. কোর্সের board-এ তখন SR-এর NACK বিট ওঠে আর DATA = 0xFFFF (Spec decision ২৬), যা তাপমাত্রা ভাবলে −0.0625 °C. যেখানে নম্বর কাটে: ঠিকানা 0x48-কেই তারের byte লেখা।
# ৩.১–৩.৪-এর চেকার: UART-এর সময় আর BRR, I2C-এর pull-up আর frame-এর সময় (পর্ব ৪৯, ৫১)
import math
line = "raw=1380 gross=1400 g tare=150 g net=1250 g price=81.88 Tk\r\n"
for baud in (9600, 115200):
print(f"{baud:6} baud: বিট {1e6/baud:6.2f} us, 8N1 byte {10e6/baud:6.1f} us,"
f" 8E1 {11e6/baud:6.1f} us, {baud // 10} B/s, {len(line)} B = {len(line) * 10e3 / baud:.2f} ms")
for fck, baud in ((8e6, 115200), (36e6, 115200), (72e6, 115200), (8e6, 460800)):
d = round(fck / baud) # 16 × USARTDIV
real = fck / d
print(f"{fck/1e6:2.0f} MHz {baud:6}: BRR=0x{d:04X} ({d >> 4} + {d & 15}/16)"
f" আসল {real:9.1f} ভুল {(real / baud - 1) * 100:+.2f} %")
print(f"board-এর uart_init: {(8_000_000 + 57600) // 115200}; আদর্শ সীমা ±{0.5 / 9.5:.2%}")
k = math.log(0.7 / 0.3) # 0.3 VDD থেকে 0.7 VDD = k·RC
rmin = (3.3 - 0.4) / 3e-3 # VOL 0.4 V at 3 mA
for mode, tr in (("Standard", 1000e-9), ("Fast", 300e-9)):
for cb in (200e-12, 400e-12):
rmax = tr / (k * cb)
print(f"{mode:8} Cb {cb*1e12:3.0f} pF: Rp {rmin:4.0f} … {rmax:5.0f} Ω",
"ঠিক" if rmax >= rmin else "অসম্ভব")
print(f"tr: 1.5 kΩ, 200 pF = {k * 1500 * 200e-12 * 1e9:.0f} ns; 4.7 kΩ, 55 pF = {k * 4700 * 55e-12 * 1e9:.0f} ns")
clocks = 9 * 5 # addr+W, reg, addr+R, MSB, LSB
print(f"0x48: W=0x{0x48 << 1:02X} R=0x{0x48 << 1 | 1:02X}, {clocks} SCL ="
f" {clocks / 100e3 * 1e6:.1f} us (100 kHz), {clocks / 400e3 * 1e6:.1f} us (400 kHz)")আসল আউটপুট (ব্রাউজারের Python):
9600 baud: বিট 104.17 us, 8N1 byte 1041.7 us, 8E1 1145.8 us, 960 B/s, 60 B = 62.50 ms
115200 baud: বিট 8.68 us, 8N1 byte 86.8 us, 8E1 95.5 us, 11520 B/s, 60 B = 5.21 ms
8 MHz 115200: BRR=0x0045 (4 + 5/16) আসল 115942.0 ভুল +0.64 %
36 MHz 115200: BRR=0x0138 (19 + 8/16) আসল 115384.6 ভুল +0.16 %
72 MHz 115200: BRR=0x0271 (39 + 1/16) আসল 115200.0 ভুল +0.00 %
8 MHz 460800: BRR=0x0011 (1 + 1/16) আসল 470588.2 ভুল +2.12 %
board-এর uart_init: 69; আদর্শ সীমা ±5.26%
Standard Cb 200 pF: Rp 967 … 5901 Ω ঠিক
Standard Cb 400 pF: Rp 967 … 2951 Ω ঠিক
Fast Cb 200 pF: Rp 967 … 1770 Ω ঠিক
Fast Cb 400 pF: Rp 967 … 885 Ω অসম্ভব
tr: 1.5 kΩ, 200 pF = 254 ns; 4.7 kΩ, 55 pF = 219 ns
0x48: W=0x90 R=0x91, 45 SCL = 450.0 us (100 kHz), 112.5 us (400 kHz)
BRR-এর চার সারি ৩.২-এর টেবিল: ভাগফল যত ছোট, গোল করার ভুল তত বড়। Pull-up-এর চার সারিতে Fast mode-এর 400 pF-ই একমাত্র “অসম্ভব”, ৩.৩(খ)-এর উত্তর। শেষ লাইন ৩.৪-এর ৪৫টি clock.
৪ · ADC, DAC আর sensor — count থেকে গ্রাম, °C আর ভোল্ট
ঝালিয়ে নিন: পর্ব ৪৭ · ADC (LSB = Vref ÷ 2n), পর্ব ৪৮ · DAC (Vout = code × Vref ÷ 2n), পর্ব ৬৫ · Sensor interfacing, পর্ব ৬৬ · Signal conditioning. স্কেলের সংখ্যা README-র: খালি 400 count, 2000 g-এ 1800, 65.50 টাকা/kg; দাম = (net × 6550 + 500) ÷ 1000 পয়সা।
৪.১১২ বিটের ADC, Vref 3.3 V. (ক) 1 LSB কত? (খ) 1.1125 V-এ code, নিচে নামানো আর গোল করা দুই নিয়মে? (গ) বাজারঘরের স্কেলে raw 1380, tare 150 g: gross, net আর দাম? (ঘ) এক count কত গ্রাম? — ১০ নম্বর (সহজ)
(ক) 3.3 ÷ 4096 = 0.8057 mV (ADC resolution). (খ) 1.1125 ÷ 0.8057 mV = 1380.8: নিচে নামিয়ে 1380, গোল করে 1381. (গ) grams = round((1380 − 400) × 2000 ÷ 1400) = 1400 g, net 1250 g, দাম (1250 × 6550 + 500) ÷ 1000 = 8188 পয়সা = 81.88 টাকা. (ঘ) 2000 ÷ 1400 = 1.4286 g, তাই quantization error ±0.714 g. নিচের stepper ধাপগুলো দেখায়; board-এর সত্যিকারের run একই লাইন দেয়:
~/lab$ python -B board.py run firmware/build/scale.elf --script firmware/scripts/scale.json
[ 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
যেখানে নম্বর কাটে: আগে ভাগ পরে গুণ (980 ÷ 1400 = 0 integer-এ), আর দাম float-এ হিসাব।
| ধাপ | |
| হিসাব | |
| ফল |
- ADC. পাল্লায় 1400 g; README-র মডেলে raw = 400 + 0.7 × 1400 = 1380 count.
- Zero বাদ। খালি পাল্লার 400 count বাদ দিলে 980 count, এটুকুই ওজনের অংশ।
- গুণ আগে। 980 × 2000 = 1,960,000; অর্ধেক ভাজক 700 যোগ করে 1,960,700; 1400 দিয়ে ভাগে 1400 g. আগে ভাগ করলে integer-এ 0 আসত।
- Tare. বোতামে রাখা 150 g বাদ: net 1250 g.
- দাম। 1250 × 6550 = 8,187,500; + 500 = 8,188,000; ÷ 1000 = 8188 পয়সা, অর্থাৎ 81.88 টাকা, board-এর UART লাইনের সঙ্গে হুবহু।
৪.২স্কেলের load cell-এর rated output 2 mV/V, excitation 3.3 V (ADC-র Vref-ও এটি), পূর্ণ মাপ 5000 g. ADC-তে খালি অবস্থায় 400 count আর ঢাল 0.7 count/g চাই। Instrumentation amplifier-এর gain, REF pin-এর ভোল্টেজ আর AD620-ধাঁচের RG (G = 1 + 49.4 kΩ ÷ RG)? 2000 g-এ code? কত গ্রামে ADC ভরে যায়? — ১০ নম্বর (মাঝারি)
- Bridge-এর পূর্ণ মাপ: 2 mV/V × 3.3 V = 6.6 mV (5000 g-এ)।
- দরকার 0.7 × 5000 = 3500 count = 3500 × 0.8057 mV = 2.8198 V; gain = 2.8198 ÷ 0.0066 = 427.2.
- REF = 400 × LSB = 0.3223 V; RG = 49.4 kΩ ÷ 426.2 = 115.9 Ω.
- 2000 g: bridge 2.640 mV → 0.3223 + 427.2 × 2.640 mV = 1.4502 V → code 1800, README-র calibration বিন্দু।
- ADC ভরে (4095 − 400) ÷ 0.7 = 5279 g-এ, 5000 g-এর capacity-র একটু ওপরে: overload চেনার জায়গা থাকে।
Excitation আর Vref একই হওয়ায় সরবরাহের ওঠানামা কেটে যায় (ratiometric). যেখানে নম্বর কাটে: REF-এর level shift ভুলে খালি পাল্লায় 0 count ধরা।
৪.৩একটি sensor −1 V থেকে +1 V দেয়, ADC-র পাল্লা 0–3.3 V (১২ বিট)। Gain আর offset কত? −0.5 V, 0 V আর +0.25 V-এ code? Code 2867 থেকে input? — ৫ নম্বর (মাঝারি)
Gain = 3.3 ÷ 2 = 1.65, −1 V-কে 0 V-এ আনতে offset 1.65 V: Vout = 1.65 Vin + 1.65. −0.5 V → 0.825 V → 1024; 0 V → 2048; +0.25 V → 2560. Code 2867 → (2867 × 0.8057 mV − 1.65) ÷ 1.65 = 0.400 V. +1 V হলে 4096, যা আঁটে না (4095-এ আটকায়); বাস্তবে gain একটু কম রাখা হয় (পর্ব ৬৬)।
৪.৪Cold room-এর TMP102-ধাঁচের sensor (১২ বিট two's complement, বাঁ-ঘেঁষা, 0.0625 °C/LSB) দুই byte দিল: (ক) 0x07 0xD0 (খ) 0xFF 0x80 (গ) 0x08 0x40 (ঘ) 0x07 0x90. প্রতিটিতে °C, firmware-এর ছাপা মান (t16 × 25 ÷ 4) আর alarm-এর নিয়মে অবস্থা? Sign extension ভুলে গেলে (খ)? — ৫ নম্বর (সহজ)
t16 = (int16_t)raw >> 4. (ক) 125 → 7.8125 °C, ছাপা 7.81: সীমার ভেতরে, কিন্তু 7.50-এর ওপরে, তাই hysteresis-এর ব্যান্ডে। (খ) −8 → −0.50 °C: LOW-এর গণনায় এক। (গ) 132 → 8.25 °C: HIGH-এর গণনায় (৮.০০-এর বেশি)। (ঘ) 121 → 7.5625 °C, ছাপা 7.56: ব্যান্ডে। Sign extension ছাড়া (খ) হয় 255.5 °C: জমে যাওয়া ঘরে “আগুন”। যেখানে নম্বর কাটে: 7.8125-কে 7.82 লেখা; firmware শূন্যের দিকে ছাঁটে।
# ৪.১–৪.৪-এর চেকার: ADC count, স্কেলের গ্রাম আর দাম, bridge-এর gain, TMP102-এর °C
LSB = 3.3 / 4096
def div_round(n, d): # README: অর্ধেকে শূন্য থেকে দূরে
return (n + d // 2) // d if n >= 0 else -((-n + d // 2) // d)
v = 1.1125
print(f"LSB {LSB*1000:.4f} mV; {v} V -> নিচে নামিয়ে {int(v / LSB)}, গোল করে {int(v / LSB + 0.5)}")
for raw, tare in ((505, 0), (1380, 150), (855, 150)):
g = div_round((raw - 400) * 2000, 1400)
p = ((g - tare) * 6550 + 500) // 1000
print(f"raw {raw}: gross {g} g, net {g - tare} g, দাম {p} পয়সা = {p / 100:.2f} টাকা")
fs = 2e-3 * 3.3 # 2 mV/V × 3.3 V, 5000 g-এ
gain = 0.7 * 5000 * LSB / fs # README: 0.7 count প্রতি g
print(f"bridge পূর্ণ ভারে {fs*1e3:.1f} mV, gain {gain:.1f}, REF {400*LSB:.4f} V,"
f" RG {49.4e3 / (gain - 1):.1f} Ω")
for g in (2000, 5000):
vo = 400 * LSB + gain * fs * g / 5000
print(f" {g} g -> {vo:.4f} V -> code {int(vo / LSB + 0.5)}")
print(f" ADC ভরে যায় {(4095 - 400) / 0.7:.0f} g-এ")
for vin in (-0.5, 0.0, 0.25): # ±1 V sensor: gain 1.65, offset 1.65 V
print(f"±1 V sensor, {vin:+} V -> code {int((1.65 * vin + 1.65) / LSB + 0.5)}")
print(f"code 2867 -> {(2867 * LSB - 1.65) / 1.65:.3f} V")
for msb, lsb in ((0x07, 0xD0), (0xFF, 0x80), (0x08, 0x40), (0x07, 0x90)):
raw = msb << 8 | lsb
t16 = (raw - 0x10000 if raw & 0x8000 else raw) >> 4
c = abs(t16) * 25 // 4 * (1 if t16 >= 0 else -1) # C-র t16*25/4
print(f"0x{raw:04X}: t16 {t16:4}, {t16 / 16:+.4f} °C, firmware {c / 100:+.2f};"
f" sign ছাড়া {(raw >> 4) / 16} °C")আসল আউটপুট (ব্রাউজারের Python):
LSB 0.8057 mV; 1.1125 V -> নিচে নামিয়ে 1380, গোল করে 1381
raw 505: gross 150 g, net 150 g, দাম 983 পয়সা = 9.83 টাকা
raw 1380: gross 1400 g, net 1250 g, দাম 8188 পয়সা = 81.88 টাকা
raw 855: gross 650 g, net 500 g, দাম 3275 পয়সা = 32.75 টাকা
bridge পূর্ণ ভারে 6.6 mV, gain 427.2, REF 0.3223 V, RG 115.9 Ω
2000 g -> 1.4502 V -> code 1800
5000 g -> 3.1421 V -> code 3900
ADC ভরে যায় 5279 g-এ
±1 V sensor, -0.5 V -> code 1024
±1 V sensor, +0.0 V -> code 2048
±1 V sensor, +0.25 V -> code 2560
code 2867 -> 0.400 V
0x07D0: t16 125, +7.8125 °C, firmware +7.81; sign ছাড়া 7.8125 °C
0xFF80: t16 -8, -0.5000 °C, firmware -0.50; sign ছাড়া 255.5 °C
0x0840: t16 132, +8.2500 °C, firmware +8.25; sign ছাড়া 8.25 °C
0x0790: t16 121, +7.5625 °C, firmware +7.56; sign ছাড়া 7.5625 °C
তিনটি দামের লাইন README-র তিনটি worked number (9.83, 81.88 আর 32.75 টাকা) আর board-এর run-এর সঙ্গে মেলে। Bridge-এর অংশ ৪.২, ±1 V-এর অংশ ৪.৩, শেষ চার লাইন ৪.৪: শুধু 0xFF80-তে sign-এর ভুল ধরা পড়ে, কারণ বাকি তিনটি ধনাত্মক।
৪.৫(ক) ৪ বিটের R-2R ladder, Vref 3.3 V, code 1011: Vout? ladder-এর R-এর সমান load দিলে? (খ) ১২ বিটের DAC-এর full scale? (গ) ৩২ ঘরের sine table (code[i] = 2048 + round(2047 sin(2πi ÷ 32))), প্রতি সেকেন্ডে 32000 sample: সুর কত, আর ঘর 4-এর code? (ঘ) 8 MHz-এর ৮ বিটের PWM থেকে τ = 1 ms-এর RC দিয়ে DAC, duty 50 %: ripple কত LSB? — ১০ নম্বর (মাঝারি)
(ক) 11 ÷ 16 × 3.3 = 2.26875 V; ladder-এর Thevenin রোধ R, তাই সমান load-এ অর্ধেক, 1.13437 V. (খ) 4095 ÷ 4096 × 3.3 = 3.29919 V = Vref − 1 LSB. (গ) 32000 ÷ 32 = 1 kHz; ঘর 4: 2048 + round(2047 × 0.7071) = 3495. (ঘ) fPWM = 8 MHz ÷ 256 = 31.25 kHz; ripple 26.399 mV = 2.05 LSB (1 LSB = 12.891 mV): ½ LSB-এ নামাতে τ আরও বড় লাগে, তাতে থিতু হওয়া ধীর। যেখানে নম্বর কাটে: full scale = Vref লেখা।
৪.৬স্কেলের ADC-র আগে 10 kΩ আর 1 µF-এর RC low-pass. Corner frequency, 50 Hz-এর hum কতটা কমে (20 count p-p থাকলে কত থাকে), আর ১২ বিটের ½ LSB-এ থিতু হতে কত সময়? প্রতি 100 ms-এর মাপের সঙ্গে এটি কি মানানসই? — ৫ নম্বর (মাঝারি)
fc = 1 ÷ (2π × 10 ms) = 15.92 Hz (cutoff frequency). 50 Hz-এ |H| = 1 ÷ √(1 + (50 ÷ 15.92)²) = 0.303 (−10.4 dB): 20 count → 6.1 count. থিতু হতে τ × ln(213) = 9.01 τ = 90.1 ms (settling time). এটি 100 ms-এর মাপের ব্যবধানের চেয়ে কম: ওজন বদলের পরের প্রথম মাপ আধা-থিতু হতে পারে, কিন্তু দ্বিতীয়টি থেকে মান স্থির।
# ৪.৫–৪.৬-এর চেকার: R-2R, DAC-এর sine table আর DDS, PWM-DAC-এর ripple, RC filter (পর্ব ৪৮, ৬৬)
import math
VREF = 3.3
print(f"R-2R 4 বিট, 1011: {0b1011 / 16 * VREF:.5f} V; সমান R load-এ (Thevenin R) {0b1011 / 16 * VREF / 2:.5f} V")
print(f"12 বিটের full scale: {4095 / 4096 * VREF:.5f} V, 1 LSB {VREF / 4096 * 1000:.4f} mV")
N, FS = 32, 32000
table = [math.floor(2048 + 2047 * math.sin(2 * math.pi * i / N) + 0.5) for i in range(N)]
print(f"sine N={N}, fs={FS} Hz -> {FS / N:.0f} Hz; ঘর 0, 4, 8, 24: {table[0]} {table[4]} {table[8]} {table[24]}")
print(f"DDS 1250 Hz: M = {round(1250 * 2**32 / FS)}; সবচেয়ে ছোট ধাপ {FS / 2**32 * 1e6:.2f} µHz")
def ripple(D, T, tau, vdd=3.3): # পর্ব ৪৮-এর সূত্র, একক RC
a, b = math.exp(-D * T / tau), math.exp(-(1 - D) * T / tau)
return vdd * (1 - a) * (1 - b) / (1 - math.exp(-T / tau))
T = 256 / 8e6 # 8 বিটের PWM, 8 MHz -> 31.25 kHz
r = ripple(0.5, T, 1e-3)
print(f"PWM-DAC 8 বিট, τ 1 ms: ripple {r*1000:.3f} mV = {r / (3.3 / 256):.2f} LSB;"
f" আসন্ন সূত্রে {3.3 * 0.25 * T / 1e-3 * 1000:.3f} mV")
R, C = 10e3, 1e-6
fc = 1 / (2 * math.pi * R * C)
g50 = 1 / math.sqrt(1 + (50 / fc) ** 2)
print(f"RC 10 kΩ, 1 µF: fc {fc:.2f} Hz, 50 Hz-এ |H| {g50:.3f} ({20 * math.log10(g50):.1f} dB),"
f" 20 count-এর hum -> {20 * g50:.1f}")
print(f"12 বিটের ½ LSB-এ থিতু: {math.log(2**13):.2f} τ = {R * C * math.log(2**13) * 1000:.1f} ms")আসল আউটপুট (ব্রাউজারের Python):
R-2R 4 বিট, 1011: 2.26875 V; সমান R load-এ (Thevenin R) 1.13437 V
12 বিটের full scale: 3.29919 V, 1 LSB 0.8057 mV
sine N=32, fs=32000 Hz -> 1000 Hz; ঘর 0, 4, 8, 24: 2048 3495 4095 1
DDS 1250 Hz: M = 167772160; সবচেয়ে ছোট ধাপ 7.45 µHz
PWM-DAC 8 বিট, τ 1 ms: ripple 26.399 mV = 2.05 LSB; আসন্ন সূত্রে 26.400 mV
RC 10 kΩ, 1 µF: fc 15.92 Hz, 50 Hz-এ |H| 0.303 (-10.4 dB), 20 count-এর hum -> 6.1
12 বিটের ½ LSB-এ থিতু: 9.01 τ = 90.1 ms
Ripple-এর সঠিক সূত্র আর আসন্ন সূত্র VDD × D(1 − D) × T ÷ τ প্রায় হুবহু মেলে (26.399 বনাম 26.400 mV), কারণ T (32 µs) τ-এর চেয়ে অনেক ছোট। DDS-এর লাইন দেখায় 1250 Hz-এর tuning word, পর্ব ৪৮-এর মতোই।
৫ · Fixed-point আর stack — float ছাড়া হিসাব, আর কত byte লাগে
ঝালিয়ে নিন: পর্ব ৪০ · Fixed-point গণিত (Qm.n, এই কোর্সের রীতিতে m-এ চিহ্ন-বিটও; Qa.b × Qc.d = Q(a+c).(b+d)), পর্ব ৩৯ · এমবেডেড memory (stack = সবচেয়ে গভীর পথের frame-এর যোগ + প্রতিটি preemption স্তরে 36 byte-এর interrupt frame + মার্জিন)।
৫.১(ক) Q1.15-এর পাল্লা আর ধাপ? (খ) 0.8 আর 0.6-এর Q1.15 integer? (গ) Cold room-এর 9.50 °C আর −0.50 °C ১৬ বিটের Q8.8 word-এ? — ৫ নম্বর (সহজ)
(ক) −1 থেকে 32767 ÷ 32768 = 0.999969, ধাপ 2−15 = 0.0000305. (খ) 0.8 × 32768 = 26214.4 → 26214; 0.6 × 32768 = 19660.8 → 19661: রূপান্তরেই সামান্য ভুল। (গ) 9.50 × 256 = 2432 = 0x0980; −0.50 × 256 = −128 = 0xFF80, README-র sensor word-এর সঙ্গে একই।
৫.২q15_mul(a, b): ৩২ বিটের গুণফল, 214 যোগ, ১৫ বিট ডানে, তারপর 32767-এ আটকানো। (ক) a = 26214, b = 19661: গুণফল, ফল আর তার মান? যোগ না করে ছাঁটলে? (খ) a = b = −32768 হলে? — ১০ নম্বর (মাঝারি)
- গুণফল 26214 × 19661 = 515,393,454 (Q2.30).
- + 16384, তারপর >> 15 → 15729 = 0.48001099; ছাঁটলে 15728, এক LSB কম। আসল 0.48 × 32768 = 15728.64, তাই 15729-ই কাছের।
- (খ) (−1) × (−1) = +1, যা Q1.15-এ নেই: 230 >> 15 = 32768 > 32767, তাই saturation দিয়ে 32767. না আটকালে int16-এ ঘুরে −32768: উল্টো চিহ্ন।
নম্বর-ভাগ: গুণফল (২), গোল করা (৪), saturation (৪)। Host-এ Clang দিয়ে চালানো C-ও একই দেয় (নিচে, ৯.৩-এর পরে)।
৫.৩স্কেলের grams = round((raw − 400) × 2000 ÷ 1400)-কে ভাগ ছাড়া লিখতে gain = round(2000 ÷ 1400 × 2n), তারপর ((raw − 400) × gain + 2n−1) >> n. n = 16-এ gain আর raw 1380-এর ফল? সবচেয়ে ছোট কোন n-এ ০–4095-এর প্রতিটি raw ভাগের সমান ফল দেয় (চেকার দেখুন)? int32-এ গুণফল আঁটে? — ১০ নম্বর (মাঝারি)
n = 16: 1.428571 × 65536 = 93623; 980 × 93623 = 91,750,540; + 32768, >> 16 → 1400 g. n = 12-এ ৭০৬টি raw-এ এক গ্রাম অমিল, n = 13-এ ০টি: সবচেয়ে ছোট নিরাপদ n = 13 (gain 11703). raw 4095-এ n = 16-এর গুণফল 345,936,985 < 231 − 1: আঁটে। যেখানে নম্বর কাটে: দুই-একটি raw পরীক্ষা করেই “মেলে” বলা; ৪০৯৬টিই চালাতে হয়।
৫.৪পর্ব ৩৯-এর stack.c-এর আসল -fstack-usage (byte): main 0, scale_task 8, read_filtered 32, adc_read 0, report 40, uart_put_i32 48, uart_put_u32 48, SysTick_Handler 0. Call: main → scale_task, uart_put_u32; scale_task → read_filtered, আর শেষে tail call report; read_filtered → adc_read; report → uart_put_i32. Main-এর সবচেয়ে খারাপ stack, tail call না বুঝে আর বুঝে; SysTick-এর frame (32 + 4 byte alignment) যোগে মোট? — ১০ নম্বর (মাঝারি)
সাধারণ ধরলে main → scale_task → report → uart_put_i32 = 0 + 8 + 40 + 48 = 96 B. কিন্তু tail call-এ scale_task-এর frame আগেই সরে যায়: 0 + 40 + 48 = 88 B. সবচেয়ে খারাপ মুহূর্তে SysTick এলে + 36 + 0 = 124 B, তারপর মার্জিন। যেখানে নম্বর কাটে: interrupt frame বাদ দেওয়া, আর recursive ফাংশনের (যেমন fib) সীমা আছে ধরা; recursion-এ stack usage-এর স্থির সীমাই নেই।
# ৫.১–৫.৪-এর চেকার: Q-format, q15_mul, স্কেলের Q-gain আর stack-এর হিসাব (পর্ব ৩৯, ৪০)
import math, fractions
to_q = lambda x, n: math.floor(x * (1 << n) + 0.5) # অর্ধেকে ওপরে গোল
print(f"Q1.15: -1 … {32767 / 32768:.6f}, ধাপ {2**-15:.7f}; 0.8 -> {to_q(0.8, 15)}, 0.6 -> {to_q(0.6, 15)};",
"Q8.8:", ", ".join(f"{t:+.2f} °C -> 0x{to_q(t, 8) & 0xFFFF:04X}" for t in (9.50, -0.50)))
def q15_mul(a, b, rnd=True):
p = a * b # Q2.30
return min((p + ((1 << 14) if rnd else 0)) >> 15, 32767), p
r, p = q15_mul(26214, 19661)
print(f"q15_mul: p = {p:,}, ফল {r} = {r / 32768:.8f}; ছাঁটলে {q15_mul(26214, 19661, False)[0]};"
f" (-1)(-1) -> {q15_mul(-32768, -32768)[0]}")
ref = lambda r: ((r - 400) * 2000 + 700) // 1400 if r >= 400 else -(((400 - r) * 2000 + 700) // 1400)
for n in (12, 13, 16):
g = round(fractions.Fraction(2000, 1400) * 2**n)
bad = sum(((r - 400) * g + (1 << (n - 1))) >> n != ref(r) for r in range(4096))
print(f"Q.{n}: gain {g}, ৪০৯৬টি raw-এ অমিল {bad}, raw 4095-এ গুণফল {3695 * g:,};"
f" raw 1380 -> {((1380 - 400) * g + (1 << (n - 1))) >> n} g")
FRAME = {"main": 0, "scale_task": 8, "read_filtered": 32, "adc_read": 0,
"report": 40, "uart_put_i32": 48, "uart_put_u32": 48}
CALLS = {"main": ["scale_task", "uart_put_u32"], "scale_task": ["read_filtered", "~report"],
"read_filtered": ["adc_read"], "report": ["uart_put_i32"]} # "~" = tail call
def worst(f, tail=True):
inside = after = 0
for c in CALLS.get(f, []):
w = worst(c.lstrip("~"), tail)
if c[0] == "~" and tail: after = max(after, w) # caller-এর frame আগেই সরেছে
else: inside = max(inside, w)
return max(FRAME[f] + inside, after)
print(f"stack: tail call না বুঝে {worst('main', False)} B, বুঝে {worst('main')} B,"
f" + ISR-এর 36 B frame = {worst('main') + 36} B")আসল আউটপুট (ব্রাউজারের Python):
Q1.15: -1 … 0.999969, ধাপ 0.0000305; 0.8 -> 26214, 0.6 -> 19661; Q8.8: +9.50 °C -> 0x0980, -0.50 °C -> 0xFF80
q15_mul: p = 515,393,454, ফল 15729 = 0.48001099; ছাঁটলে 15728; (-1)(-1) -> 32767
Q.12: gain 5851, ৪০৯৬টি raw-এ অমিল 706, raw 4095-এ গুণফল 21,619,445; raw 1380 -> 1400 g
Q.13: gain 11703, ৪০৯৬টি raw-এ অমিল 0, raw 4095-এ গুণফল 43,242,585; raw 1380 -> 1400 g
Q.16: gain 93623, ৪০৯৬টি raw-এ অমিল 0, raw 4095-এ গুণফল 345,936,985; raw 1380 -> 1400 g
stack: tail call না বুঝে 96 B, বুঝে 88 B, + ISR-এর 36 B frame = 124 B
Q.12 থেকে Q.13-এ লাফ চোখে পড়ার মতো: gain-এর গোল করার ভুল raw-এর পাল্লা (3695) দিয়ে গুণ হয়ে অর্ধেক গ্রাম ছাড়ায় কি না, তা-ই ঠিক করে। stack-এর লাইন পর্ব ৩৯-এর estimate.py-র 96, 88 আর 124 B-এর সঙ্গে মেলে।
৬ · CAN আর Modbus — বিট গোনা, CRC আর bus-এর সময়
ঝালিয়ে নিন: পর্ব ৫২ · CAN bus (standard data frame-এ n byte: stuffing ছাড়া 44 + 8n বিট, stuffing-এর অংশ 34 + 8n; পাঁচটি একই বিটের পরে উল্টো বিট; TEC +8/−1, ≥128 error-passive, ≥256 bus-off), পর্ব ৫৩ · Modbus (CRC-16: শুরু 0xFFFF, polynomial 0xA001, নিচের byte আগে)।
৬.১Cold-storage-এর CAN bus, 125 kbit/s, standard ID. T1 (ID 0x101, data 04 00) প্রতি সেকেন্ডে একবার, একইভাবে T2 (0x102, 08 40), T3 (0x103, 05 80) আর compressor (0x200, 01). (ক) T1-এর frame-এ কতগুলো stuff বিট, মোট বিট (IFS-সহ) আর সময়? (খ) Bus load? (গ) ৮ byte-এর frame-এর সবচেয়ে খারাপ দৈর্ঘ্য? (ঘ) চারটি একসঙ্গে শুরু করলে পাঠানোর ক্রম? — ১০ নম্বর (মাঝারি)
- (ক) SOF থেকে CRC পর্যন্ত 34 + 16 = 50 বিট (CRC-15 = 0x470A). চালিয়ে দেখলে ৫টি stuff বিট: 55 বিট; সঙ্গে CRC delimiter, ACK ২, EOF ৭, IFS ৩: 68 বিট = 544 µs (প্রতি বিট 8 µs).
- (খ) T2, T3-ও 68 বিট, compressor 60: সেকেন্ডে 264 বিট = 0.211 %.
- (গ) 44 + 64 = 108, সবচেয়ে বেশি (34 + 64 − 1) ÷ 4 = 24টি stuff, + IFS 3: 135 বিট = 1080 µs.
- (ঘ) ছোট ID জেতে (dominant 0): T1 → T2 → T3 → compressor. T1 আর T2 তারের বিট ১১-এ আলাদা হয় (SOF = বিট ০, stuff বিটসহ গুনে), সেখানে T2 হারে (পর্ব ৫২-এর run).
যেখানে নম্বর কাটে: CRC-কে stuffing-এর বাইরে ধরা (CRC-ও stuffing পায়), আর IFS-কে frame-এর সময়ে না ধরা।
৬.২T3-এর transceiver-এর তার ছিঁড়ে গেল: প্রতিটি পাঠানোয় bit error. কয়টি ব্যর্থ চেষ্টার পরে error-passive, কয়টিতে bus-off? Bus-off থেকে ফিরতে 128 × ১১টি recessive বিট লাগলে 125 kbit/s আর 500 kbit/s-এ সর্বনিম্ন সময়? — ৫ নম্বর (মাঝারি)
প্রতিবার TEC + 8: ১৬টিতে 128 → error-passive, ৩২টিতে 256 → bus-off. ফেরা: 1408 বিট × 8 µs = 11.264 ms; 500 kbit/s-এ 2.816 ms. একা থাকা node-এর ACK error-এ error-passive অবস্থায় TEC আর বাড়ে না (Bosch-এর ব্যতিক্রম), তাই সে 128-এ আটকে থাকে, bus-off হয় না।
# ৬.১–৬.৩-এর চেকার: CAN-এর CRC-15, bit stuffing, frame-এর সময় আর bus-off (পর্ব ৫২-এর ফাংশন হুবহু)
def bits(v, n): return [(v >> (n - 1 - i)) & 1 for i in range(n)]
def crc15(bs):
reg = 0
for b in bs:
nxt = b ^ (reg >> 14)
reg = (reg << 1) & 0x7FFF
if nxt: reg ^= 0x4599 # x^15+x^14+x^10+x^8+x^7+x^4+x^3+1
return reg
def stuff(bs): # ৫টি একই বিটের পরে উল্টো বিট
out, run, last, where = [], 0, None, []
for b in bs:
out.append(b)
run = run + 1 if b == last else 1
last = b
if run == 5:
out.append(1 - b); where.append(len(out) - 1)
last, run = 1 - b, 1 # stuff বিটও পরের গোনায়
return out, where
BIT_US, total = 8, 0 # 125 kbit/s
for ident, data in ((0x101, [4, 0]), (0x102, [8, 0x40]), (0x103, [5, 0x80]), (0x200, [1])):
raw = [0] + bits(ident, 11) + [0, 0, 0] + bits(len(data), 4) + [b for x in data for b in bits(x, 8)]
wire, where = stuff(raw + bits(crc15(raw), 15))
n = len(wire) + 13 # + CRC delim, ACK 2, EOF 7, IFS 3
total += n
print(f"0x{ident:03X}: CRC 0x{crc15(raw):04X}, {len(raw) + 15} -> {len(wire)} বিট, {n} বিট = {n * BIT_US} us")
print(f"প্রতি সেকেন্ডে {total} বিট: bus load {total / 125000:.3%}")
w8 = 44 + 8 * 8 + (34 + 8 * 8 - 1) // 4 + 3
print(f"৮ byte-এর সবচেয়ে খারাপ frame {w8} বিট = {w8 * BIT_US} us; TEC 16 x 8 = {16 * 8}, 32 x 8 = {32 * 8}")
print(f"bus-off থেকে ফেরা: 128 x 11 বিট = {128 * 11 * BIT_US / 1000:.3f} ms")আসল আউটপুট (ব্রাউজারের Python):
0x101: CRC 0x470A, 50 -> 55 বিট, 68 বিট = 544 us
0x102: CRC 0x0287, 50 -> 55 বিট, 68 বিট = 544 us
0x103: CRC 0x3FC7, 50 -> 55 বিট, 68 বিট = 544 us
0x200: CRC 0x1F47, 42 -> 47 বিট, 60 বিট = 480 us
প্রতি সেকেন্ডে 264 বিট: bus load 0.211%
৮ byte-এর সবচেয়ে খারাপ frame 135 বিট = 1080 us; TEC 16 x 8 = 128, 32 x 8 = 256
bus-off থেকে ফেরা: 128 x 11 বিট = 11.264 ms
চারটি frame-এরই ৫টি করে stuff বিট (50 → 55, 42 → 47), যা পর্ব ৫২-এর bus_timing.py-র 68 আর 60 বিটের সঙ্গে মেলে। Bus load এক শতাংশের অনেক নিচে; সময়ের চিন্তা তাই অপেক্ষার সবচেয়ে খারাপ অবস্থা নিয়ে, গড় নিয়ে নয়।
৬.৩Modbus RTU: master slave 1-কে register 0 থেকে দুটি পড়তে বলে, 01 03 00 00 00 02. (ক) প্রতিটি byte-এর পরে CRC আর শেষ CRC? তারে কোন দুই byte যায়? (খ) Slave পুরো frame-এর CRC হিসাব করলে কী পায়? (গ) 9600 baud, 8E1-এ এক অক্ষর, t3.5 আর এক poll-এর (৮ byte প্রশ্ন + ৯ byte উত্তর + দুটি নীরবতা) সর্বনিম্ন সময়? — ১০ নম্বর (মাঝারি)
(ক) নিচের stepper প্রতিটি byte দেখায়: শেষে 0x0BC4, তারে নিচের byte আগে: 01 03 00 00 00 02 C4 0B. (খ) CRC-সহ পুরো frame-এর CRC = 0000: এটিই slave-এর পরীক্ষা; পথে একটি byte বদলালে 0AA0, slave চুপ থাকে। (গ) ১১ বিট ÷ 9600 = 1.146 ms, t3.5 = 4.010 ms, poll ≥ 17 অক্ষর + 2 × 3.5 = 24 অক্ষর = 27.50 ms. যেখানে নম্বর কাটে: 0B C4 লেখা; Modbus-এ বাকি সব big-endian, শুধু CRC little-endian.
| byte | |
| XOR-এর পরে | |
| ৮ shift-এর পরে | |
| তারে |
- শুরু। CRC = 0xFFFF, সব বিট 1.
- 01. FFFF ^ 01 = FFFE; ৮ বার ডানে সরানোর পরে 807E.
- 03. 807E ^ 03 = 807D → 2140.
- 00. শূন্যের XOR কিছু বদলায় না: 2140, তবু ৮টি shift-এ F020.
- 00. F020 → D8F1.
- 00. D8F1 → 8419.
- 02. 8419 ^ 02 = 841B → 0BC4. তারে নিচের byte আগে: C4, তারপর 0B.
# ৬.৪-এর চেকার: Modbus RTU-র CRC-16 (পর্ব ৫৩-এর crc16 হুবহু), প্রতি byte-এর পরে CRC আর সময়
def crc16(data):
crc = 0xFFFF # ধাপ ১: সব বিট 1
for b in data:
crc ^= b # ধাপ ২: নিচের byte-এ XOR
for _ in range(8): # ধাপ ৩-৫: ৮ বার ডানে সরানো
crc = (crc >> 1) ^ 0xA001 if crc & 1 else crc >> 1
return crc
pdu = bytes([0x01, 0x03, 0x00, 0x00, 0x00, 0x02])
print("প্রতি byte-এর পরে:", " ".join(f"{crc16(pdu[:k]):04X}" for k in range(1, 7)))
c = crc16(pdu)
frame = pdu + bytes([c & 0xFF, c >> 8]) # নিচের byte আগে
print(f"CRC = 0x{c:04X}; তারে: {frame.hex(' ').upper()}; পুরো frame-এর CRC = {crc16(frame):04X}")
print("check '123456789':", f"{crc16(b'123456789'):04X}", "| 02 07:", f"{crc16(bytes([2, 7])):04X}")
resp = bytes.fromhex("01 03 04 01 90 00 00 FB E2")
print("উত্তর ঠিক?", crc16(resp) == 0, "| reg0 =", int.from_bytes(resp[3:5], "big", signed=True) / 100, "°C")
bad = bytearray(frame); bad[5] = 0x20
print("পথে byte বদলালে CRC =", f"{crc16(bad):04X}", "-> slave চুপ")
for baud in (9600, 19200):
ch = 11 / baud * 1000 # 8E1 = ১১ বিট, ms
print(f"{baud} baud: অক্ষর {ch:.3f} ms, t3.5 = {3.5 * ch:.3f} ms,"
f" এক poll ≥ {(8 + 9) * ch + 2 * 3.5 * ch:.2f} ms")আসল আউটপুট (ব্রাউজারের Python):
প্রতি byte-এর পরে: 807E 2140 F020 D8F1 8419 0BC4
CRC = 0x0BC4; তারে: 01 03 00 00 00 02 C4 0B; পুরো frame-এর CRC = 0000
check '123456789': 4B37 | 02 07: 1241
উত্তর ঠিক? True | reg0 = 4.0 °C
পথে byte বদলালে CRC = 0AA0 -> slave চুপ
9600 baud: অক্ষর 1.146 ms, t3.5 = 4.010 ms, এক poll ≥ 27.50 ms
19200 baud: অক্ষর 0.573 ms, t3.5 = 2.005 ms, এক poll ≥ 13.75 ms
প্রথম লাইন stepper-এর শেষ সারির সঙ্গে মেলে। দুটি test vector (4B37 আর spec-এর উদাহরণ 1241) দেখায় ফাংশনটি ঠিক; board-এর আসল উত্তর-frame (পর্ব ৫৩) পরীক্ষায় পাস করে, আর reg0 = 400 মানে 4.00 °C. Host-এ Clang-এর C-ও 0x0BC4 দেয় (নিচে, ৯.৩-এর পরে)।
৭ · RTOS — utilization, response time আর queue
ঝালিয়ে নিন: পর্ব ৫৪ · Real-time system (U = Σ C ÷ T), পর্ব ৫৬ · RTOS-এর scheduling (Liu–Layland সীমা n(21/n − 1), শুধু যথেষ্ট শর্ত; RTA: R = C + Σ⌈R ÷ Tj⌉ Cj), পর্ব ৫৮ · Queue. Simulator-এর নিয়ম: বড় সংখ্যা = বড় priority (Spec decision ৩২), বিশ্লেষণ Spec decision ৩৬.
৭.১Cold room-এর তিন task (tick-এ): SENS C = 1, T = 4; UI C = 2, T = 6; TELE C = 3, T = 12; deadline = period. (ক) U আর Liu–Layland পরীক্ষা কী বলে? (খ) Rate-monotonic priority-তে প্রতিটির R? (গ) Priority উল্টে দিলে (TELE সবার ওপরে)? — ১০ নম্বর (মাঝারি)
- (ক) U = 1/4 + 2/6 + 3/12 = 0.8333 > 0.7798 (n = 3): পরীক্ষা কিছু বলে না (U ≤ 1, তাই RTA লাগে)। সীমা পেরোনো মানে “অচল” নয়।
- (খ) SENS R = 1, UI R = 2 + ⌈3/4⌉ × 1 = 3, TELE R = 10 (stepper দেখুন): সবাই deadline-এর ভেতরে।
- (গ) TELE 3, UI 2 + ⌈5/12⌉ × 3 = 5, SENS 1 + 3 + 2 = 6 > 4: MISS. একই U, অন্য priority-তে deadline হারায়।
সত্যিকারের run (reference lab-এর rtos_sim.py, scenario cold3.json = তিনটি task, rate-monotonic):
~/lab$ python -B rtos_sim.py analyze cold3.json
tasks (highest priority first): SENS(C=1,T=4), UI(C=2,T=6), TELE(C=3,T=12)
U = 1/4 + 2/6 + 3/12 = 0.8333
Liu-Layland bound n(2^(1/n)-1) for n=3: 0.7798
U > bound but U <= 1: the bound test is inconclusive, use response-time analysis
R(SENS) = 1 (deadline 4) OK
R(UI) = 3 (deadline 6) OK
R(TELE) = 10 (deadline 12) OK
hyperperiod = 12 ticks
~/lab$ python -B rtos_sim.py run cold3.json --no-trace (অংশ)
012345678901
SENS #...#...#...
UI -##...##....
TELE ---#-#---#..
TELE released 0 start 3 finish 10 response 10 deadline 12 met
CPU busy 10 of 12 ticks (83.3 %)
যেখানে নম্বর কাটে: U > সীমা দেখে “schedule হয় না” লেখা, আর RTA-য় নিচের priority-র task-কে বাধা হিসেবে যোগ করা।
| আগের R | |
| SENS-এর বাধা | |
| UI-এর বাধা | |
| নতুন R |
- শুরু। R = TELE-এর নিজের C = 3.
- প্রথম ঘুর। ৩ tick-এ SENS একবার, UI একবার ছাড়া পায়: 3 + 1 + 2 = 6.
- দ্বিতীয়। ৬ tick-এ SENS দুবার (t = 0, 4): 3 + 2 + 2 = 7.
- তৃতীয়। ৭ tick-এ UI-ও দুবার (t = 0, 6): 3 + 2 + 4 = 9.
- চতুর্থ। ৯ tick-এ SENS তিনবার (0, 4, 8): 3 + 3 + 4 = 10.
- স্থির। ১০-এ নতুন কোনো release নেই: R = 10 ≤ 12, OK. Simulator-এর TELE-এর response-ও 10.
৭.২(ক) T1 (1, 4), T2 (2, 6), T3 (1, 8): U, সীমা আর R? (খ) T1 (3, 6), T2 (4, 9): U, সীমা আর T2-এর R? (C, T) জোড়া, rate-monotonic. — ১০ নম্বর (মাঝারি)
(ক) U = 0.7083 ≤ 0.7798: সীমাতেই প্রমাণ; R = 1, 3, 4. (খ) U = 0.9444 > 0.8284; T2: 4 → 4 + ⌈4/6⌉ × 3 = 7 → 4 + ⌈7/6⌉ × 3 = 10 > 9: MISS. Simulator-এ T2-এর প্রথম job শেষ হয় 10-এ (README). লক্ষ করুন: U < 1 হলেও miss. যেখানে নম্বর কাটে: RTA-র iteration 7-এ থামানো।
৭.৩Sensor task প্রতি ১০ tick-এ (1 s) একটি reading queue-তে পাঠায় (নিজের C = 1, priority বেশি); logic task-এর সবচেয়ে লম্বা কাজ 35 tick, তখন সে queue পড়ে না। Queue-র capacity কমপক্ষে কত, যাতে sensor কখনো আটকে না যায়? — ৫ নম্বর (কঠিন)
Logic-এর ব্যস্ত সময় RTA-র ধাঁচে: R = 35 + ⌈R ÷ 10⌉ × 1: 35 → 39 → 39 tick (3.9 s). এই সময়ে phase অজানা হলে ⌈39 ÷ 10⌉ = ৪টি reading জমে; কাজ ঠিক একটি reading-এর পরে শুরু হলে ৩টি। নিরাপদ capacity 4. যেখানে নম্বর কাটে: 35 ÷ 10 = 3.5 → 3 লেখা; sensor-এর নিজের বাধায় logic আরও দেরি করে।
# ৭.১–৭.৪-এর চেকার: U, Liu–Layland সীমা, response-time analysis আর queue-র গভীরতা (পর্ব ৫৬, ৫৮)
from math import ceil
from fractions import Fraction
def analyse(title, tasks): # tasks: (নাম, C, T), বড় priority আগে
n = len(tasks)
U = sum(Fraction(c, t) for _, c, t in tasks)
print(f"{title}: U = {float(U):.4f}, n = {n}-এর সীমা {n * (2 ** (1 / n) - 1):.4f}")
for i, (name, c, t) in enumerate(tasks):
r, steps = c, [c]
while True:
nxt = c + sum(ceil(r / tj) * cj for _, cj, tj in tasks[:i])
steps.append(nxt)
if nxt == r or nxt > t:
break
r = nxt
print(f" {name:4} R: {' → '.join(map(str, steps))} (D={t})", "OK" if nxt <= t else "MISS")
cold = [("SENS", 1, 4), ("UI", 2, 6), ("TELE", 3, 12)]
analyse("RM ক্রম", cold)
analyse("উল্টো ক্রম", cold[::-1])
analyse("rm.json", [("T1", 1, 4), ("T2", 2, 6), ("T3", 1, 8)])
analyse("rm_unschedulable", [("T1", 3, 6), ("T2", 4, 9)])
R = 35 # logic-এর লম্বা কাজ 35 tick, sensor C=1, T=10
while 35 + ceil(R / 10) * 1 != R:
R = 35 + ceil(R / 10) * 1
print(f"queue: R = {R} tick; phase অজানা হলে {ceil(R / 10)}টি জমে, reading-এর সঙ্গে মিলে শুরু হলে {R // 10}টি")আসল আউটপুট (ব্রাউজারের Python):
RM ক্রম: U = 0.8333, n = 3-এর সীমা 0.7798
SENS R: 1 → 1 (D=4) OK
UI R: 2 → 3 → 3 (D=6) OK
TELE R: 3 → 6 → 7 → 9 → 10 → 10 (D=12) OK
উল্টো ক্রম: U = 0.8333, n = 3-এর সীমা 0.7798
TELE R: 3 → 3 (D=12) OK
UI R: 2 → 5 → 5 (D=6) OK
SENS R: 1 → 6 (D=4) MISS
rm.json: U = 0.7083, n = 3-এর সীমা 0.7798
T1 R: 1 → 1 (D=4) OK
T2 R: 2 → 3 → 3 (D=6) OK
T3 R: 1 → 4 → 4 (D=8) OK
rm_unschedulable: U = 0.9444, n = 2-এর সীমা 0.8284
T1 R: 3 → 3 (D=6) OK
T2 R: 4 → 7 → 10 (D=9) MISS
queue: R = 39 tick; phase অজানা হলে 4টি জমে, reading-এর সঙ্গে মিলে শুরু হলে 3টি
চারটি বিশ্লেষণ ৭.১ আর ৭.২-এর উত্তর, প্রতিটি iteration-সহ। “উল্টো ক্রম”-এ U আর সীমা একই থাকে, অথচ SENS হারে: সীমার পরীক্ষা priority-র ক্রম দেখে না, RTA দেখে। Simulator-এর analyze নির্দিষ্ট non-RM ক্রমেও সীমার লাইন ছাপে, তাই রায় সবসময় R-এর লাইন থেকে নিন।
৮ · Power আর নির্ভরযোগ্যতা — গড় current, আয়ু আর MTBF
ঝালিয়ে নিন: পর্ব ৬০ · Low-power নকশা (STM32F103 datasheet-এর typical মান), পর্ব ৬২ · Power budget (Iavg = Σ Ii ti ÷ T; আয়ু = ব্যবহারযোগ্য mAh ÷ Iavg), পর্ব ৬৩ · নির্ভরযোগ্যতা (λ = FIT × 10−9/h, MTBF = 1 ÷ λ, R(t) = e−λt, A = MTBF ÷ (MTBF + MTTR)). “ধরা মান” লেখা সংখ্যা শেখার জন্য, কোনো datasheet-এর নয়।
৮.১Cold-room monitor প্রতি 1 s-এ জেগে 2 ms কাজ করে (Run, HSI 8 MHz, 4.9 mA), বাকি সময় Stop mode (14 µA) + RTC (1.4 µA). গড় current কত? সবসময় Run-এ polling (5.5 mA)-এর তুলনায় কত গুণ কম? জাগার অংশ আর ঘুমের অংশ আলাদা করে? — ৫ নম্বর (সহজ)
(4.9 mA × 2 ms + 0.0154 mA × 998 ms) ÷ 1000 ms = 9.8 + 15.4 = 25.2 µA; polling 5500 µA, তাই প্রায় ২১৯ গুণ কম। ঘুমের অংশ (15.4 µA) জাগার অংশের (9.8 µA) চেয়ে বড়: এখানে কাজ ছোট করার চেয়ে ঘুম গভীর করা বেশি লাভের। যেখানে নম্বর কাটে: mA আর µA মিশিয়ে যোগ।
৮.২Battery-চালিত cold room-এর এক period (10 s)-এর budget (µA × s): MCU Stop 14 × 9.99, RTC 1.4 × 10, MCU Run 5500 × 0.01, sensor 4.8 × 10, Wi-Fi deep sleep 10 × 9, LDO 5 × 10, Wi-Fi burst 120000 × 1 (ধরা)। (ক) গড় current আর burst-এর ভাগ? (খ) 2500 mAh-এ আয়ু, derating ছাড়া আর 0.70 × 0.80 × 0.98 × 0.90 দিয়ে? (গ) Telemetry প্রতি 300 s-এ (reading প্রতি 1 s থাকে) হলে? — ১০ নম্বর (মাঝারি)
- (ক) মোট 120,396.86 µA·s ÷ 10 s = 12.040 mA; Wi-Fi burst একাই 99.67 %.
- (খ) 2500 ÷ 12.04 = 207.6 h = 8.65 দিন; derating-এর গুণক 0.4939 → 1234.8 mAh → 102.6 h = 4.27 দিন.
- (গ) প্রতি সেকেন্ডের মেঝে 30.7 µA + deep sleep 9.97 µA + burst 120000 ÷ 300 = 400 µA: 440.7 µA → 116.8 দিন.
যেখানে নম্বর কাটে: datasheet-এর সবচেয়ে কম current দিয়ে budget শুরু করা; এখানে radio ছাড়া বাকি সব মিলে এক শতাংশও নয়।
৮.৩(ক) এক device-এর অংশগুলোর মোট 1300 FIT (series): λ, MTBF, R(1 বছর), R(5 বছর), আর ২০০টি device-এ বছরে আশা করা ব্যর্থতা? (খ) Firmware গড়ে 720 h-এ একবার আটকায়: সকালে হাতে চালু করলে (MTTR 12 h) আর watchdog-এ (0.2 s) availability আর বছরে বন্ধ থাকার সময়? (গ) একটি channel-এর R = 0.9 হলে TMR-এর R? R = 0.3 হলে? — ১০ নম্বর (মাঝারি)
(ক) λ = 1.3 × 10−6/h, MTBF = 769,231 h ≈ 87.8 বছর; R(1) = 0.9887, R(5) = 0.9447; ২০০টিতে বছরে 2.28টি. MTBF ৮৮ বছর মানে কোনো device ৮৮ বছর চলবে না, মানে বড় fleet-এ ব্যর্থতার হার। (খ) হাতে: A = 0.98361, বছরে ~143.6 h বন্ধ; watchdog: A = 0.99999992, বছরে মাত্র 2.4 s. (গ) 3R² − 2R³: 0.9 → 0.972; 0.3 → 0.216, একটির চেয়েও খারাপ (R < 0.5-এ ভোট ক্ষতি করে)।
# ৮.১–৮.৪-এর চেকার: গড় current, battery-র আয়ু, MTBF, R(t), availability আর TMR (পর্ব ৬০, ৬২, ৬৩)
import math
avg = lambda ia, ta, ir, T=1000.0: (ia * ta + ir * (T - ta)) / T # mA আর ms
a, d = avg(5.5, 1000, 0), avg(4.9, 2.0, 0.014 + 0.0014)
print(f"polling {a * 1000:.1f} uA, Stop + RTC {d * 1000:.1f} uA -> {a / d:.0f} গুণ কম")
rows = [(14.0, 9.99), (1.4, 10), (5500.0, 0.01), (4.8, 10), (10.0, 9.0), (5.0, 10), (120000.0, 1.0)]
q = sum(i * t for i, t in rows) # uA*s প্রতি 10 s
i_ma = q / 10 / 1000
print(f"budget: {q:.2f} uA*s / 10 s = {i_ma:.3f} mA; Wi-Fi burst-এর ভাগ {120000 / q:.2%}")
k = 0.70 * 0.80 * 0.98 * 0.90
for c in (2500.0, 2500.0 * k):
print(f"{c:7.1f} mAh / {i_ma:.3f} mA = {c / i_ma:6.1f} h = {c / i_ma / 24:.2f} দিন")
per_s = 14.0 * 0.999 + 5500.0 * 0.001 + 1.4 + 4.8 + 5.0
t = 300
i300 = per_s + 10.0 * (t - 1) / t + 120000.0 / t
print(f"telemetry প্রতি {t} s: {i300:.1f} uA -> {2500 * k / (i300 / 1000) / 24:.1f} দিন")
lam = 1300e-9 # 1300 FIT, প্রতি ঘণ্টায়
print(f"MTBF {1 / lam:,.0f} h = {1 / lam / 8760:.1f} বছর; R(1 বছর) {math.exp(-lam * 8760):.4f},"
f" R(5 বছর) {math.exp(-lam * 5 * 8760):.4f}; 200টিতে বছরে {200 * 8760 * lam:.2f}টি")
for who, mttr in (("হাতে, 12 h", 12), ("watchdog, 0.2 s", 0.2 / 3600)):
A = 720 / (720 + mttr)
print(f"{who}: A = {A:.8f}, বছরে বন্ধ {(1 - A) * 8760 * 3600:,.1f} s")
for r in (0.9, 0.5, 0.3):
print(f"TMR: R = {r} -> {3 * r**2 - 2 * r**3:.4f}")আসল আউটপুট (ব্রাউজারের Python):
polling 5500.0 uA, Stop + RTC 25.2 uA -> 219 গুণ কম
budget: 120396.86 uA*s / 10 s = 12.040 mA; Wi-Fi burst-এর ভাগ 99.67%
2500.0 mAh / 12.040 mA = 207.6 h = 8.65 দিন
1234.8 mAh / 12.040 mA = 102.6 h = 4.27 দিন
telemetry প্রতি 300 s: 440.7 uA -> 116.8 দিন
MTBF 769,231 h = 87.8 বছর; R(1 বছর) 0.9887, R(5 বছর) 0.9447; 200টিতে বছরে 2.28টি
হাতে, 12 h: A = 0.98360656, বছরে বন্ধ 516,983.6 s
watchdog, 0.2 s: A = 0.99999992, বছরে বন্ধ 2.4 s
TMR: R = 0.9 -> 0.9720
TMR: R = 0.5 -> 0.5000
TMR: R = 0.3 -> 0.2160
সংখ্যাগুলো পর্ব ৬০, ৬২ আর ৬৩-এর duty.py, budget.py, life.py, telem.py আর relcalc.py-এর আউটপুটের সঙ্গে হুবহু। Availability-র দুই সারি একই MTBF-এ: পার্থক্য পুরোটাই MTTR থেকে।
৯ · Filter আর PID — কয়েকটি sample আর একটি ধাপ
ঝালিয়ে নিন: পর্ব ৬৮ · Digital filtering (EMA: y ← y + α(x − y), τ ≈ Ts(1 − α) ÷ α, α ≈ 2 ÷ (N + 1); Kalman gain K = P ÷ (P + r)), পর্ব ৬৯ · PID control (u = Kpe + I + Kd Δmeas ÷ Ts, e = মাপ − setpoint, D মাপ থেকে; u-র ভগ্নাংশ 1 = 100 % cooling).
৯.১স্কেলে প্রতি 10 ms-এ এক নমুনা: 1400, 1400, 1400, 1400, তারপর 2000, 2000, … (ক) চার নমুনার moving average আর α = 1/4-এর EMA-র (শুরু 1400) চতুর্থ নমুনা থেকে আউটপুট? (খ) 1400, 1402, 3000, 1399, 1401-এর পাঁচ নমুনার median আর গড়? — ৫ নম্বর (সহজ)
(ক) MA 4: 1400, 1550, 1700, 1850, 2000: ঠিক ৪ ধাপে পুরো ওজন। EMA: 1400, 1550, 1662.5, 1746.9, 1810.2, 1857.6, 1893.2: ধীরে কাছে যায়, কখনো পুরো পৌঁছায় না। (খ) median 1401; গড় 1720.4: একটি ধাক্কা গড়কে ৩২০ গ্রাম টেনে নেয়, median-কে নয়।
৯.২(ক) Ts = 10 ms, α = 1/4-এর EMA-র time constant আর প্রায় সমান মসৃণ moving average-এর N? (খ) A = 0.98, dt = 10 ms-এর complementary filter-এর τ? (গ) এক-মাত্রার Kalman filter, r = 49, q = 0, শুরু P = r: প্রথম চারটি K? — ৫ নম্বর (মাঝারি)
(ক) τ ≈ 10 × 0.75 ÷ 0.25 = 30 ms; N ≈ 2 ÷ α − 1 = 7. (খ) τ = A·dt ÷ (1 − A) = 0.49 s. (গ) K = 0.500, 0.333, 0.250, 0.200: q = 0 মানে “ওজন কখনো বদলায় না”, তাই K শূন্যের দিকে নামে, আর নতুন ওজনে filter সাড়াই দেয় না (পর্ব ৬৮-এ q = 4-এ K থামে প্রায় 0.248-এ)।
৯.৩Cold room-এর PID: Kp = 0.30 প্রতি °C, Ki = 0.002 প্রতি °C·s, Kd = 3.0 s প্রতি °C, Ts = 1 s, setpoint 4.00 °C, D মাপ থেকে। আগের মাপ 4.50 °C, এখন 4.375 °C, আগের I = 0.60. (ক) P, I, D আর u? (খ) Firmware-এর Q16 gain (1228800, 8192, 12288000; sensor 1/16 °C, আদেশ ‰-এ) দিয়ে u? (গ) ঘরের মডেলে (বাইরে 30 °C, cooling 40 °C × u) শুধু P (0.30) দিলে ঘর কোথায় থামে? — ১৫ নম্বর (কঠিন)
- (ক) e = 0.375 °C. P = 0.30 × 0.375 = 0.1125; I = 0.60 + 0.002 × 0.375 × 1 = 0.60075; D = 3.0 × (4.375 − 4.50) = −0.375; u = 0.33825 ≈ 33.8 %. ঘর ঠান্ডা হচ্ছে, তাই D ব্রেক কষে।
- (খ) t16: এখন 70, আগে 72, setpoint 64, e = 6. P = 1228800 × 6 = 7,372,800; I = 600 × 216 + 8192 × 6 = 39,370,752; D = 12288000 × (70 − 72) = −24,576,000. যোগ + 32768, >> 16 = 338 ‰, float-এর 338.25-এর সঙ্গে মেলে।
- (গ) স্থির অবস্থায় 30 − T = 40 × 0.30 × (T − 4): e = 26 ÷ (1 + 12) = 2.00 °C, ঘর 6.00 °C-এ থামে; পর্ব ৬৯-এর মডেলেও শুধু P-তে 6.00. এই steady-state error মোছে I.
নম্বর-ভাগ: float-এর ধাপ (৬), Q16 (৬), স্থির অবস্থা (৩)। যেখানে নম্বর কাটে: e = setpoint − মাপ লেখা (ঠান্ডা করার যন্ত্রে চিহ্ন উল্টো), আর D-তে error-এর বদলে মাপের পার্থক্য ভুলে যাওয়া।
# ৯.১–৯.৪-এর চেকার: moving average, EMA, median, Kalman gain আর একটি PID ধাপ (পর্ব ৬৮, ৬৯)
xs = [1400] * 4 + [2000] * 6 # স্কেলে হঠাৎ 1400 g থেকে 2000 g
ma4 = [sum(xs[max(0, i - 3):i + 1]) / min(4, i + 1) for i in range(len(xs))]
y, ema = xs[0], []
for x in xs:
y += (x - y) / 4 # EMA, α = 1/4
ema.append(y)
print("MA 4 :", " ".join(f"{v:.0f}" for v in ma4[3:]))
print("EMA ¼:", " ".join(f"{v:.1f}" for v in ema[3:]))
sp = [1400, 1402, 3000, 1399, 1401] # একটি ধাক্কা
print("median 5:", sorted(sp)[2], "| গড় 5:", sum(sp) / 5)
Ts, a = 10, 0.25
print(f"EMA τ ≈ {Ts * (1 - a) / a:.0f} ms; সমান মসৃণ MA-র N ≈ {2 / a - 1:.0f};"
f" complementary τ = {0.98 * 0.01 / (1 - 0.98):.2f} s")
p, r, ks = 49.0, 49.0, []
for _ in range(4):
k = p / (p + r); p *= 1 - k; ks.append(f"{k:.3f}")
print("Kalman K (q = 0):", " ".join(ks))
Kp, Ki, Kd, SP = 0.30, 0.002, 3.0, 4.00
prev, now, I = 4.50, 4.375, 0.60
e = now - SP
P, I, D = Kp * e, I + Ki * e * 1, Kd * (now - prev) / 1
print(f"float: e={e} P={P:.4f} I={I:.5f} D={D:.4f} u={P + I + D:.5f}")
KP_Q, KI_Q, KD_Q = 1228800, 8192, 12288000 # pid_core.h-এর Q16 মান
e16, integ = 70 - 64, 600 << 16 # 4.375 °C = 70/16, I = 600 ‰
pq, iq, dq = KP_Q * e16, integ + KI_Q * e16, KD_Q * (70 - 72)
print(f"Q16: P {pq:,} I {iq:,} D {dq:,} -> u = {(pq + iq + dq + 32768) >> 16} ‰")
print(f"শুধু P: e = 26 / (1 + 40 x 0.30) = {26 / 13:.2f} °C -> ঘর থামে {4 + 26 / 13:.2f} °C-এ")আসল আউটপুট (ব্রাউজারের Python):
MA 4 : 1400 1550 1700 1850 2000 2000 2000
EMA ¼: 1400.0 1550.0 1662.5 1746.9 1810.2 1857.6 1893.2
median 5: 1401 | গড় 5: 1720.4
EMA τ ≈ 30 ms; সমান মসৃণ MA-র N ≈ 7; complementary τ = 0.49 s
Kalman K (q = 0): 0.500 0.333 0.250 0.200
float: e=0.375 P=0.1125 I=0.60075 D=-0.3750 u=0.33825
Q16: P 7,372,800 I 39,370,752 D -24,576,000 -> u = 338 ‰
শুধু P: e = 26 / (1 + 40 x 0.30) = 2.00 °C -> ঘর থামে 6.00 °C-এ
Python-এর integer অসীম বড়, তাই Q16-এর লাইন C-তে কোথায় ৬৪ বিট লাগে তা দেখায় না। সেটি দেখতে একই হিসাব C-তে int64_t দিয়ে, Clang দিয়ে compile করে চালানো হলো।
সত্যিকারের run (host-এ C, ziglang 0.17.1-এর Clang 22.1.8, -O2 -std=c11 -Wall -Wextra; ফাইল hostchk.c: Modbus CRC, q15_mul, PID-এর Q16 ধাপ আর স্কেলের Q16 gain):
~/lab$ python -m ziglang cc -O2 -std=c11 -Wall -Wextra -fno-sanitize=undefined hostchk.c -o hostchk
~/lab$ ./hostchk
modbus crc = 0x0BC4 -> wire C4 0B
q15_mul(26214, 19661) = 15729
q15_mul(-32768, -32768) = 32767
pid: p=7372800 i=39370752 d=-24576000 u=338 permille
grams=1400 net=1250 price=8188 paisa
১০ · IoT — LoRa-র airtime, link budget, MQTT-এর byte আর int8
ঝালিয়ে নিন: পর্ব ৭২ · LPWAN (Tsym = 2SF ÷ BW, Semtech-এর time-on-air সূত্র, FSPL = 20 log dkm + 20 log fMHz + 32.44), পর্ব ৭৩ · MQTT (remaining length ৭ বিট করে), পর্ব ৭৪ · CoAP আর HTTP, পর্ব ৭৮ · Edge AI (symmetric s = max|w| ÷ 127; asymmetric s = (rmax − rmin) ÷ 255, z = round(−128 − rmin ÷ s)).
১০.১Cold room-এর LoRaWAN uplink: 4 byte app data + 13 byte LoRaWAN overhead = 17 byte PHY payload, 125 kHz, CR 4/5, preamble 8. SF7, SF10 আর SF12-এ Tsym, payload-এর symbol, time-on-air, আর 1 % duty cycle মানতে সর্বনিম্ন period? একই SF12-এ 57 byte-এর JSON পাঠালে? — ১০ নম্বর (মাঝারি)
Tsym: 1.024, 8.192, 32.768 ms. Payload-এর symbol: 38, 28, 28 (SF12-এ low data rate optimize, DE = 1). ToA = (8 + 4.25 + n) × Tsym: 51.456 ms, 329.728 ms, 1318.912 ms. 1 %-এর মধ্যে থাকতে period ≥ ToA × 100: 5.15 s, 32.97 s, 131.89 s. SF12-এ JSON: 2957.3 ms, প্রায় সোয়া দুই গুণ: binary payload-এর লাভ এখানেই। যেখানে নম্বর কাটে: preamble-এর 4.25 symbol বাদ দেওয়া, আর SF এক বাড়লে সময় ঠিক দ্বিগুণ ধরা (n বদলায়)।
১০.২Link budget: device 14 dBm, antenna 2 dBi আর gateway-এ 5 dBi, cable 2 dB, দূরত্ব 5 km, 868 MHz, দেয়াল আর গাছের বাড়তি ক্ষতি 35 dB (ধরা)। Gateway-এর NF 6 dB, BW 125 kHz; SNRmin: SF7 −7.5, SF10 −15, SF12 −20 dB. Prx, প্রতিটি SF-এর sensitivity আর margin; 10 dB margin চাইলে কোন SF? — ১০ নম্বর (মাঝারি)
- FSPL = 20 log 5 + 20 log 868 + 32.44 = 105.19 dB; Prx = 14 + 2 + 5 − 2 − 105.19 − 35 = −121.19 dBm.
- Noise + NF = −174 + 10 log 125000 + 6 = −117.03 dBm; sensitivity = তার সঙ্গে SNRmin: −124.53, −132.03, −137.03 dBm.
- Margin: SF7 3.34 dB (সরু), SF8 5.84, SF9 8.34, SF10 10.84 dB, SF12 15.84 dB: SF10-ই সবচেয়ে কম SF যেখানে 10 dB থাকে।
যেখানে নম্বর কাটে: dBm আর dB গুলিয়ে ফেলা, আর বাড়তি ক্ষতি (35 dB) বাদ দিয়ে free space ধরা।
১০.৩MQTT 3.1.1: topic bazarghar/coldroom/1/temp (25 byte), payload ৫৭ byte-এর JSON. QoS 0, 1, 2-এ PUBLISH-এর remaining length আর ack-সহ মোট byte (ack প্রতিটি 4 byte), প্রতি 10 s-এ পাঠালে দিনে কত KiB? Remaining length 321-এর encoding? একই data CoAP-এর confirmable GET-এ (2 byte token, তিনটি Uri-Path) request কত byte? — ১০ নম্বর (মাঝারি)
Remaining = 2 + 25 + (QoS > 0 হলে 2) + 57 = 84 আর 86; মোট 1 + 1 + remaining + ack: QoS 0 86 B, QoS 1 92 B (PUBACK), QoS 2 100 B (তিনটি ack). দিনে ৮৬৪০টি: 725.6, 776.2, 843.8 KiB. 321 = 2 × 128 + 65: c1 02 (নিচের ৭ বিট আগে, MSB = আরও আছে)। CoAP: 4 header + 2 token + (1 + 8) + (1 + 1) + (1 + 4) = 22 B; তারে CON আর ACK মিলিয়ে IP/UDP-সহ 144 B, HTTP/1.1 খোলা সংযোগে 371, নতুন সংযোগে 651 B (পর্ব ৭৪-এর capture). TCP/IP আর TLS-এর খরচ MQTT-এর সংখ্যায় ধরা নেই।
১০.৪TinyML-এর int8 quantization: (ক) weight [0.82, −1.27, 0.05, 0.40], symmetric: scale আর int8 মান? (খ) একটি activation-এর পাল্লা 0 থেকে 9.85, asymmetric: scale আর zero point, আর 4.00-এর int8 মান ও ফেরত মান? — ৫ নম্বর (মাঝারি)
(ক) s = 1.27 ÷ 127 = 0.01, q = [82, −127, 5, 40]; এখানে ফেরত মান হুবহু, কারণ প্রতিটি 0.01-এর গুণিতক। (খ) s = 9.85 ÷ 255 = 0.038627, zero point z = round(−128 − 0) = −128; 4.00 → round(103.55) − 128 = −24, ফেরত (−24 + 128) × s = 4.0173: ভুল s ÷ 2-এর মধ্যে। যেখানে নম্বর কাটে: activation-এর জন্যও symmetric ধরা; ReLU-র পরের মান কখনো ঋণাত্মক নয়, তখন int8-এর অর্ধেক পাল্লা নষ্ট হয়।
# ১০.১–১০.২-এর চেকার: LoRa-র time-on-air (পর্ব ৭২-এর airtime_ms হুবহু) আর link budget
import math
def airtime_ms(pl, sf, bw=125_000, cr=1, preamble=8):
de = 1 if (bw == 125_000 and sf >= 11) else 0 # low data rate optimize
tsym = 2 ** sf / bw * 1000 # এক symbol, ms
num = 8 * pl - 4 * sf + 28 + 16 # CRC আছে, explicit header
n_pay = 8 + max(math.ceil(num / (4 * (sf - 2 * de))) * (cr + 4), 0)
return (preamble + 4.25) * tsym + n_pay * tsym, tsym, n_pay
for sf in (7, 10, 12):
t, tsym, n = airtime_ms(4 + 13, sf) # 4 B app + 13 B LoRaWAN
print(f"SF{sf:<2}: Tsym {tsym:6.3f} ms, n_pay {n}, ToA {t:8.3f} ms,"
f" 1% duty-তে period ≥ {t * 100 / 1000:6.2f} s")
print(f"57 B JSON, SF12: ToA {airtime_ms(57 + 13, 12)[0]:.1f} ms")
fspl = 20 * math.log10(5.0) + 20 * math.log10(868.0) + 32.44
rx = 14 + 2 + 5 - 2 - fspl - 35 # Ptx+Gtx+Grx-cable-FSPL-extra
noise = -174 + 10 * math.log10(125_000) + 6 # NF 6 dB
print(f"FSPL {fspl:.2f} dB, Prx {rx:.2f} dBm, noise + NF {noise:.2f} dBm")
for sf, snr in ((7, -7.5), (8, -10), (9, -12.5), (10, -15), (12, -20)):
m = rx - (noise + snr)
print(f" SF{sf:<2}: sensitivity {noise + snr:.2f} dBm, margin {m:5.2f} dB",
"ঠিক" if m >= 10 else "সরু")আসল আউটপুট (ব্রাউজারের Python):
SF7 : Tsym 1.024 ms, n_pay 38, ToA 51.456 ms, 1% duty-তে period ≥ 5.15 s
SF10: Tsym 8.192 ms, n_pay 28, ToA 329.728 ms, 1% duty-তে period ≥ 32.97 s
SF12: Tsym 32.768 ms, n_pay 28, ToA 1318.912 ms, 1% duty-তে period ≥ 131.89 s
57 B JSON, SF12: ToA 2957.3 ms
FSPL 105.19 dB, Prx -121.19 dBm, noise + NF -117.03 dBm
SF7 : sensitivity -124.53 dBm, margin 3.34 dB সরু
SF8 : sensitivity -127.03 dBm, margin 5.84 dB সরু
SF9 : sensitivity -129.53 dBm, margin 8.34 dB সরু
SF10: sensitivity -132.03 dBm, margin 10.84 dB ঠিক
SF12: sensitivity -137.03 dBm, margin 15.84 dB ঠিক
ToA-র তিনটি মান পর্ব ৭২-এর airtime.py-র 17 byte-এর টেবিলের সঙ্গে মেলে, link budget-এর লাইন link_budget.py-র সঙ্গে। SF10 থেকে SF12-এ margin 5 dB বাড়ে, কিন্তু airtime চার গুণ: battery আর duty cycle দুটোই সেই দাম দেয়।
# ১০.৩–১০.৫-এর চেকার: MQTT আর CoAP-এর byte, আর int8 quantization (পর্ব ৭৩, ৭৪, ৭৮)
def rem_len(n): # Remaining Length: 7 বিট করে, MSB = আরও আছে
out = bytearray()
while True:
n, d = divmod(n, 128)
out.append(d | (0x80 if n else 0))
if n == 0:
return bytes(out)
topic = "bazarghar/coldroom/1/temp"
payload = '{"dev":"coldroom-1","seq":1,"temp_c":7.00,"alarm":"HIGH"}'
for qos in (0, 1, 2):
body = 2 + len(topic) + (2 if qos else 0) + len(payload)
total = 1 + len(rem_len(body)) + body + 4 * (0, 1, 3)[qos]
print(f"QoS {qos}: remaining {body}, ack-সহ {total} B, দিনে {total * 8640 / 1024:.1f} KiB")
print("remaining length:", ", ".join(f"{n} -> {rem_len(n).hex(' ')}" for n in (127, 128, 321, 16384)))
coap = 4 + 2 + (1 + 8) + (1 + 1) + (1 + 4) # header, token, তিনটি Uri-Path
print(f"CoAP GET {coap} B; তারে: CoAP {22 + 66 + 2 * 28}, HTTP খোলা সংযোগে {50 + 201 + 3 * 40},"
f" নতুন সংযোগে {50 + 201 + 10 * 40} B")
w = [0.82, -1.27, 0.05, 0.40]
s = max(abs(x) for x in w) / 127 # symmetric: z = 0
q = [round(x / s) for x in w]
print(f"weight: s = {s:.4f}, q = {q}, ফেরত {[round(v * s, 2) for v in q]}")
lo, hi = 0.0, 9.85 # activation-এর পাল্লা
sa = (hi - lo) / 255
za = round(-128 - lo / sa)
qa = round(4.00 / sa) + za
print(f"activation: s = {sa:.6f}, z = {za}; 4.00 -> {qa}, ফেরত {(qa - za) * sa:.4f}")আসল আউটপুট (ব্রাউজারের Python):
QoS 0: remaining 84, ack-সহ 86 B, দিনে 725.6 KiB
QoS 1: remaining 86, ack-সহ 92 B, দিনে 776.2 KiB
QoS 2: remaining 86, ack-সহ 100 B, দিনে 843.8 KiB
remaining length: 127 -> 7f, 128 -> 80 01, 321 -> c1 02, 16384 -> 80 80 01
CoAP GET 22 B; তারে: CoAP 144, HTTP খোলা সংযোগে 371, নতুন সংযোগে 651 B
weight: s = 0.0100, q = [82, -127, 5, 40], ফেরত [0.82, -1.27, 0.05, 0.4]
activation: s = 0.038627, z = -128; 4.00 -> -24, ফেরত 4.0173
তিনটি QoS-এর সারি পর্ব ৭৩-এর topic_budget.py-র 86, 92 আর 100 byte-এর সঙ্গে মেলে। rem_len পর্ব ৭৩-এর ফাংশনের হুবহু কপি; 16384-এ তিন byte লাগে। int8-এর শেষ লাইনে ফেরত মান 4.0173, ভুল 0.0173 < s ÷ 2 = 0.0193.
শেষ মুহূর্তের নিয়ম-তালিকা আর সাধারণ ভুল
| বিষয় | নিয়ম | সাধারণ ভুল | পর্ব |
|---|---|---|---|
| SysTick | LOAD = f × t − 1, ২৪ বিট | −1 বাদ; 72 MHz-এ 250 ms | ৩৩, ৪৪ |
| Timer | f = fTIM ÷ ((PSC + 1)(ARR + 1)), দুটিই ১৬ বিট | APB-এর ×2 ভুলে যাওয়া | ৪৪ |
| PWM | duty = CCR ÷ (ARR + 1); বিট = log2(ARR + 1) | CCR ÷ ARR | ৪৫ |
| UART | BRR = round(f ÷ baud); 8N1 = ১০ বিট | শুধু BRR-এর ভুল দেখা | ৪৯ |
| I2C | Rp: (VDD − VOL) ÷ IOL থেকে tr ÷ 0.8473Cb | tr = RC | ৫১ |
| ADC | LSB = Vref ÷ 2n; integer-এ আগে গুণ | আগে ভাগ, sign extension ভুলে যাওয়া | ৪৭, ৫১ |
| Fixed-point | Q×Q-এ বিন্দু যোগ হয়; + অর্ধেক, তারপর shift; saturate | ছাঁটা, (−1)(−1) | ৪০ |
| CAN | 44 + 8n বিট + stuff + IFS 3; ছোট ID জেতে | CRC-তে stuffing নেই ভাবা | ৫২ |
| Modbus | CRC নিচের byte আগে; পুরো frame-এর CRC = 0 | 0B C4 | ৫৩ |
| RTA | R = C + Σ⌈R ÷ Tj⌉Cj, স্থির না হওয়া পর্যন্ত | U > সীমা = অচল ভাবা | ৫৬ |
| Power | Iavg = Σ I·t ÷ T; derating আগে | radio-র burst ছোট করে দেখা | ৬০, ৬২ |
| নির্ভরযোগ্যতা | MTBF = 109 ÷ FIT; A = MTBF ÷ (MTBF + MTTR) | MTBF = আয়ু ভাবা | ৬৩ |
| PID | e = মাপ − setpoint; D মাপ থেকে | চিহ্ন উল্টো, Ts ভুলে যাওয়া | ৬৯ |
| LoRa / MQTT | ToA-তে preamble + 4.25; 1 % = ToA × 100; ack-এর byte | SF বাড়লে শুধু দ্বিগুণ ধরা | ৭২, ৭৩ |
১৫ মিনিটের মিনি-সেট — ঘড়ি ধরে করুন
আটটি ছোট প্রশ্ন, প্রতিটিতে দুই মিনিটের মতো। কাগজ-কলম চলবে, চেকার নয়। ৭–৮ ঠিক হলে প্রস্তুত; ৫–৬ হলে সংশ্লিষ্ট অংশ আবার করুন।
- 8 MHz-এ 5 ms-এর SysTick tick: LOAD?
- 72 MHz-এর timer, PSC 71, ARR 4999: update frequency?
- 8 MHz, 9600 baud (১৬ গুণ oversampling): BRR আর ভুল?
- ১২ বিটের ADC, 3.3 V, code 2048: ভোল্টেজ?
- 0.25-এর Q1.15 মান (দশমিক আর hex)?
- তিন task (C, T) = (1, 5), (2, 10), (3, 20): Liu–Layland পরীক্ষা কী বলে?
- প্রতি 100 s-এ 1 s ধরে 10 mA, বাকি সময় 20 µA: গড়?
- LoRa SF9, 125 kHz: এক symbol কত ms?
উত্তরমিনি-সেটের উত্তর আর এক লাইনের কারণ (নিজে করার পরে খুলুন)
1. 39999 8,000,000 × 0.005 − 1
2. 200 Hz 72 MHz ÷ (72 × 5000)
3. 833 = 0x341 8e6 ÷ 9600 = 833.3; ভুল +0.04 %
4. 1.65 V 2048 × 3.3 ÷ 4096
5. 8192 = 0x2000 0.25 × 32768
6. schedulable U = 0.55 ≤ 0.7798
7. 119.8 µA (10 × 1 + 0.02 × 99) ÷ 100 mA
8. 4.096 ms 2^9 ÷ 125000 s
সবচেয়ে বেশি ভুল হয় ২ আর ৭-এ। ২-এ PSC আর ARR দুটিতেই +1 লাগে; ৭-এ µA-কে mA-তে নিয়ে তবে যোগ করুন।
আরও গভীরে: এই পাতার timer, UART আর power-এর সংখ্যা STM32F103-এর reference manual (RM0008) আর datasheet-এর typical মান থেকে, যেভাবে পর্ব ৩৩, ৪৪, ৪৯ আর ৬০ উদ্ধৃত করেছে; অন্য chip-এ সীমা আর current আলাদা, তাই পরীক্ষায় প্রশ্নের দেওয়া মানই ব্যবহার করুন। LoRa-র ToA সূত্র Semtech-এর SX1276 datasheet আর AN1200.13-এর, I2C-এর pull-up NXP UM10204-এর, CAN-এর নিয়ম Bosch CAN 2.0-এর আর Modbus-এর CRC “Modbus over Serial Line V1.02”-এর। Liu আর Layland-এর সীমা ১৯৭৩ সালের প্রবন্ধের; এটি শুধু যথেষ্ট শর্ত, তাই আধুনিক RTOS-এর নকশায় RTA বা simulation দিয়েই চূড়ান্ত প্রমাণ দেওয়া হয়।
পরীক্ষা ও ইন্টারভিউতে: “1 kHz-এর interrupt-এর PSC/ARR দিন” — মোট ভাগ, তারপর ১৬ বিটে ভাগাভাগি। “115200 baud কি 8 MHz-এ চলবে” — BRR, ভুল %, তারপর clock-এর ভুল যোগ। “এই task-গুলো schedule হবে?” — U, সীমা, আর সীমা পেরোলে RTA. “Battery কত দিন চলবে?” — সারি ধরে I × t, period দিয়ে ভাগ, derating. “ADC count থেকে °C বা গ্রাম” — zero, span, integer-এ আগে গুণ, আর ঋণাত্মক মানের sign extension.
AI-এর যুগে — AI-এর হিসাব যাচাই
AI সহকারী এই হিসাবগুলো দ্রুত লেখে, আর প্রায়ই এই পাতার ফাঁদেই পড়ে: PSC বা LOAD-এ “−1” ভুলে যায়, APB-এর timer-এর ×2 জানে না, একটি chip-এর সীমা অন্য chip-এ বসায় বা register-এর নাম বানায়, BRR-এর ভুলকেই পুরো বাজেট ধরে, I2C-এর rise time-কে RC বলে, float-এ দাম হিসাব করে পয়সা হারায়, RTA-র বদলে শুধু U দেখে রায় দেয়, battery-র mAh-কে derating ছাড়াই ভাগ করে, আর LoRa-র airtime-এ preamble বাদ দেয়। প্রতিকার: সূত্রের উৎস পর্ব বা datasheet-এর সঙ্গে মেলান, প্রতিটি সংখ্যা একটি ছোট চেকারে চালান, আর ফলের একক ও মাত্রা নিজে বিচার করুন (৮৮ বছরের MTBF মানে ৮৮ বছরের আয়ু নয়)।
নিজের উত্তর AI-কে দিয়ে পরীক্ষা করানোর একটি কাঠামো:
AI-এর উত্তর হাতে পেলে — যাচাইয়ের চেকলিস্ট
নিজেকে যাচাই করুন
ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন। সব তথ্য প্রশ্নের ভেতরেই আছে।
ক্রমএকটি battery-চালিত sensor node-এর আয়ু হিসাবের ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)
- প্রতিটি mode-এর current datasheet থেকে, শর্তসহ, তালিকায় লেখা
- এক period-এ প্রতিটি mode কত সময় চলে, ঠিক করা
- প্রতিটি সারির I × t যোগ করে মোট charge বের করা
- মোট charge-কে period দিয়ে ভাগ করে গড় current পাওয়া
- Derating-এর পরের ব্যবহারযোগ্য mAh-কে গড় current দিয়ে ভাগ করা
(সহজ) SysTick 8 MHz core clock গোনে। প্রতি 1 ms-এ একটি interrupt চাইলে LOAD কত?
- 8000
- 7999
- 799
- 79999
(সহজ) ১২ বিটের ADC, Vref 3.3 V. এক LSB প্রায় কত?
- 1.611 mV
- 3.223 mV
- 0.806 mV
- 0.403 mV
(মাঝারি) STM32F1-ধাঁচের UART, fCK = 8 MHz, ১৬ গুণ oversampling, 115200 baud. BRR আর baud-এর ভুল কত?
- 0x45, +0.64 %
- 0x45, −0.64 %
- 0x46, −0.79 %
- 0x271, 0 %
(মাঝারি) Rate-monotonic priority-তে তিন task (C, T): (1, 4), (2, 6), (3, 12), deadline = period. সবচেয়ে কম priority-র task-এর worst-case response time?
- 3
- 6
- 12
- 10
(মাঝারি) MQTT-এ remaining length 321 কোন byte-গুলোয় লেখা হয়?
- 01 41
- c1 02
- c1 01
- 41 02
(কঠিন) Q1.15-এ a = 26214 (≈ 0.8), b = 19661 (≈ 0.6). (a × b + 214) >> 15-এর ফল কত?
- 15728
- 515393454
- 15729
- 32767
শব্দকোষ
লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব শব্দ এখানে একসাথে:
মনে রাখুন
- Register-এর হিসাব: SysTick LOAD = f × t − 1 (২৪ বিট); timer-এ (PSC + 1)(ARR + 1) = fTIM ÷ f (দুটিই ১৬ বিট); duty = CCR ÷ (ARR + 1); BRR = round(f ÷ baud).
- সংখ্যার পথ: LSB = Vref ÷ 2n; integer-এ আগে গুণ, পরে গোল করে ভাগ; ঋণাত্মক sensor-এ sign extension; Q-গুণে অর্ধেক যোগ, shift, saturate.
- Bus: UART-এর ভুলের বাজেটে BRR আর clock দুটিই; I2C-এর Rp একটি জানালা; CAN-এ stuff বিট আর IFS; Modbus-এর CRC নিচের byte আগে।
- সময়ের প্রমাণ: U ≤ সীমা হলে নিশ্চিত, না হলে RTA; queue-র গভীরতা = ধীর পাঠকের ব্যস্ত সময়ে কয়টি আসে।
- System: গড় current সারি ধরে, derating-এর পরে আয়ু; MTBF হার, আয়ু নয়; LoRa-র airtime-এ preamble আর 1 %-এর নিয়ম; int8-এ s আর z.
আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ
- মাইক্রোপ্রসেসর, এমবেডেড সিস্টেম ও IoT · কোর্স হোম৮৫টি পর্বপুরো কোর্সের মানচিত্র আর ১৪টি মডিউল।
- পর্ব ৪৪ · Timer আর counter — prescaler, overflow, input capture আর output compareআবার পড়ুনPSC/ARR-এর সব জোড়া আর shadow register.
- পর্ব ৪৯ · UART — baud rate, frame, parity আর ring bufferআবার পড়ুনBRR, oversampling আর ভুলের বাজেট।
- পর্ব ৫৬ · RTOS-এর task আর scheduling — preemption, priority আর rate monotonicআবার পড়ুনLiu–Layland সীমা আর RTA-র উৎস।
- পর্ব ৬২ · Power budget আর battery-র আয়ুর হিসাবআবার পড়ুনBudget-এর টেবিল, derating আর telemetry-র period.
- পর্ব ৮১ · 8085 আর 8086-এর সমস্যা অনুশীলন — program, timing আর interfacingপাশের পর্বMicroprocessor-এর অর্ধেকের সমাধানসহ সমস্যা।
- Computer Architecture পর্ব ৫৮ · Numerical সমস্যাপাশের ট্র্যাকসংখ্যা পদ্ধতি, CPI, pipeline আর cache-এর গাণিতিক অনুশীলন।