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

এমবেডেড নকশার গাণিতিক সমস্যা — timer, baud rate, ADC, power আর scheduling

Practice: Embedded Design Numericals — Clock Trees, SysTick, Timer and PWM Settings, UART Baud Error, I2C Pull-ups, ADC and Sensor Scaling, DAC, Fixed-Point, Stack Size, CAN and Modbus, RTOS Schedulability, Power Budgets, Reliability, Filters, PID, LoRa, MQTT and int8 Quantization

Taught in Bangla, this practice page collects the calculations of modules 5–13 into 34 numericals in nine groups, each with marks and a model answer: clock trees and SysTick, timer and PWM settings, UART baud error and I2C pull-ups, ADC, DAC and fixed-point, stack size, CAN and Modbus CRC, RTOS schedulability, power and MTBF, filters and PID, LoRa airtime, MQTT bytes and int8. Twelve Pyodide blocks recheck every number, with real runs from the virtual board, rtos_sim.py and Clang-compiled C.

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

  • 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 আর একক → সূত্র আর তার উৎস → একক সঙ্গে নিয়ে হিসাব → integer, সীমা আর গোল করা → কোডে মেলানো
  1. Data আর একক: clock কোন bus-এর, সময় ms না µs, current mA না µA, আর কোনটি “ধরা মান” (datasheet-এর নয়)।
  2. সূত্র: কোন পর্বের কোন সূত্র, এক লাইনে লিখুন। পরীক্ষক সূত্র দেখেই অর্ধেক নম্বর দেন।
  3. একক নিয়ে হিসাব: mA × ms = µC, uA·s ÷ s = uA; একক না মিললে ভুল সেখানেই।
  4. Integer আর সীমা: register কয় বিট (SysTick ২৪, timer-এর PSC/ARR ১৬), “−1”, গোল করার নিয়ম আর overflow.
  5. মেলানো: প্রতিটি অংশের শেষে একটি Python চেকার; চালিয়ে নিজের খাতার সঙ্গে মেলান।

ছবি ৮৪.১ — কোন অংশে কোন ধরনের হিসাব, আর মূল পর্ব

নীল microcontroller-এর peripheral, সবুজ analog আর সংখ্যা, বেগুনি bus আর RTOS, কমলা system আর IoT

Map of the practice groups: peripherals, analog and numbers, buses and RTOS, system and IoT, with their source lessons Clock, SysTick,timer আর PWM UART-এর BRR,I2C-এর pull-up ADC, DAC আরsensor-এর gain Q-format আরstack-এর আকার CAN-এর বিট,Modbus-এর CRC U, RTA আরqueue-র গভীরতা গড় current, আয়ু,MTBF Filter আরএকটি PID ধাপ LoRa, MQTT,CoAP, int8 অংশ ২পর্ব ৩৩, ৪৪, ৪৫ অংশ ৩পর্ব ৪৯, ৫১ অংশ ৪পর্ব ৪৭, ৪৮, ৬৫, ৬৬ অংশ ৫পর্ব ৩৯, ৪০ অংশ ৬পর্ব ৫২, ৫৩ অংশ ৭পর্ব ৫৪, ৫৬, ৫৮ অংশ ৮পর্ব ৬০, ৬২, ৬৩ অংশ ৯পর্ব ৬৮, ৬৯ অংশ ১০পর্ব ৭২–৭৪, ৭৮ প্রতিটি উত্তর: চেকার চালিয়ে মেলান

কোন 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 লিখল: কী হয়? — ১০ নম্বর (মাঝারি)
  1. মোট ভাগ N = fTIM ÷ f = (PSC + 1)(ARR + 1), আর দুটিই ১৬ বিট (0–65535).
  2. (ক) PSC + 1 = 72 MHz × 1 µs = 72, তাই PSC 71, ARR 999. (খ) PSC + 1 = 7200: PSC 7199, ARR 9999.
  3. (গ) N = 72,000,000 ÷ 44,100 = 1632.65, পূর্ণসংখ্যায় 1633: PSC 0, ARR 1632, আসল 44090.631 Hz, ভুল −212 ppm. N পূর্ণসংখ্যা নয় বলে কোনো জোড়াই হুবহু মেলে না।
  4. (ঘ) 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 কি নিরাপদ? — ১০ নম্বর (মাঝারি)
  1. 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 ২৪)।
  2. 36 MHz: 312.5 → 0x138 (19 + 8/16), +0.16 %. 72 MHz: 625 = 0x271, ভুল 0.
  3. 8 MHz-এ 460800: 17.36 → 0x11, আসল 470588 baud, +2.12 %.
  4. আদর্শ সীমা 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-এ হিসাব।

README-র স্কেল: zero 400, span 1400 count = 2000 g, 6550 পয়সা/kg
ধাপ
হিসাব
ফল
  1. ADC. পাল্লায় 1400 g; README-র মডেলে raw = 400 + 0.7 × 1400 = 1380 count.
  2. Zero বাদ। খালি পাল্লার 400 count বাদ দিলে 980 count, এটুকুই ওজনের অংশ।
  3. গুণ আগে। 980 × 2000 = 1,960,000; অর্ধেক ভাজক 700 যোগ করে 1,960,700; 1400 দিয়ে ভাগে 1400 g. আগে ভাগ করলে integer-এ 0 আসত।
  4. Tare. বোতামে রাখা 150 g বাদ: net 1250 g.
  5. দাম। 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 ভরে যায়? — ১০ নম্বর (মাঝারি)
  1. Bridge-এর পূর্ণ মাপ: 2 mV/V × 3.3 V = 6.6 mV (5000 g-এ)।
  2. দরকার 0.7 × 5000 = 3500 count = 3500 × 0.8057 mV = 2.8198 V; gain = 2.8198 ÷ 0.0066 = 427.2.
  3. REF = 400 × LSB = 0.3223 V; RG = 49.4 kΩ ÷ 426.2 = 115.9 Ω.
  4. 2000 g: bridge 2.640 mV → 0.3223 + 427.2 × 2.640 mV = 1.4502 V → code 1800, README-র calibration বিন্দু।
  5. 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 হলে? — ১০ নম্বর (মাঝারি)
  1. গুণফল 26214 × 19661 = 515,393,454 (Q2.30).
  2. + 16384, তারপর >> 15 → 15729 = 0.48001099; ছাঁটলে 15728, এক LSB কম। আসল 0.48 × 32768 = 15728.64, তাই 15729-ই কাছের।
  3. (খ) (−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-এর সবচেয়ে খারাপ দৈর্ঘ্য? (ঘ) চারটি একসঙ্গে শুরু করলে পাঠানোর ক্রম? — ১০ নম্বর (মাঝারি)
  1. (ক) SOF থেকে CRC পর্যন্ত 34 + 16 = 50 বিট (CRC-15 = 0x470A). চালিয়ে দেখলে ৫টি stuff বিট: 55 বিট; সঙ্গে CRC delimiter, ACK ২, EOF ৭, IFS ৩: 68 বিট = 544 µs (প্রতি বিট 8 µs).
  2. (খ) T2, T3-ও 68 বিট, compressor 60: সেকেন্ডে 264 বিট = 0.211 %.
  3. (গ) 44 + 64 = 108, সবচেয়ে বেশি (34 + 64 − 1) ÷ 4 = 24টি stuff, + IFS 3: 135 বিট = 1080 µs.
  4. (ঘ) ছোট 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: CRC-এর নিচের byte-এ XOR, তারপর ৮ বার ডানে (বিট 0 = 1 হলে ^ 0xA001)
byte
XOR-এর পরে
৮ shift-এর পরে
তারে
  1. শুরু। CRC = 0xFFFF, সব বিট 1.
  2. 01. FFFF ^ 01 = FFFE; ৮ বার ডানে সরানোর পরে 807E.
  3. 03. 807E ^ 03 = 807D → 2140.
  4. 00. শূন্যের XOR কিছু বদলায় না: 2140, তবু ৮টি shift-এ F020.
  5. 00. F020 → D8F1.
  6. 00. D8F1 → 8419.
  7. 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 সবার ওপরে)? — ১০ নম্বর (মাঝারি)
  1. (ক) U = 1/4 + 2/6 + 3/12 = 0.8333 > 0.7798 (n = 3): পরীক্ষা কিছু বলে না (U ≤ 1, তাই RTA লাগে)। সীমা পেরোনো মানে “অচল” নয়।
  2. (খ) SENS R = 1, UI R = 2 + ⌈3/4⌉ × 1 = 3, TELE R = 10 (stepper দেখুন): সবাই deadline-এর ভেতরে।
  3. (গ) 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-কে বাধা হিসেবে যোগ করা।

Rk+1 = 3 + ⌈Rk ÷ 4⌉ × 1 + ⌈Rk ÷ 6⌉ × 2
আগের R
SENS-এর বাধা
UI-এর বাধা
নতুন R
  1. শুরু। R = TELE-এর নিজের C = 3.
  2. প্রথম ঘুর। ৩ tick-এ SENS একবার, UI একবার ছাড়া পায়: 3 + 1 + 2 = 6.
  3. দ্বিতীয়। ৬ tick-এ SENS দুবার (t = 0, 4): 3 + 2 + 2 = 7.
  4. তৃতীয়। ৭ tick-এ UI-ও দুবার (t = 0, 6): 3 + 2 + 4 = 9.
  5. চতুর্থ। ৯ tick-এ SENS তিনবার (0, 4, 8): 3 + 3 + 4 = 10.
  6. স্থির। ১০-এ নতুন কোনো 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 থাকে) হলে? — ১০ নম্বর (মাঝারি)
  1. (ক) মোট 120,396.86 µA·s ÷ 10 s = 12.040 mA; Wi-Fi burst একাই 99.67 %.
  2. (খ) 2500 ÷ 12.04 = 207.6 h = 8.65 দিন; derating-এর গুণক 0.4939 → 1234.8 mAh → 102.6 h = 4.27 দিন.
  3. (গ) প্রতি সেকেন্ডের মেঝে 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) দিলে ঘর কোথায় থামে? — ১৫ নম্বর (কঠিন)
  1. (ক) 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 ব্রেক কষে।
  2. (খ) 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-এর সঙ্গে মেলে।
  3. (গ) স্থির অবস্থায় 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? — ১০ নম্বর (মাঝারি)
  1. FSPL = 20 log 5 + 20 log 868 + 32.44 = 105.19 dB; Prx = 14 + 2 + 5 − 2 − 105.19 − 35 = −121.19 dBm.
  2. Noise + NF = −174 + 10 log 125000 + 6 = −117.03 dBm; sensitivity = তার সঙ্গে SNRmin: −124.53, −132.03, −137.03 dBm.
  3. 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.

শেষ মুহূর্তের নিয়ম-তালিকা আর সাধারণ ভুল

বিষয়নিয়মসাধারণ ভুলপর্ব
SysTickLOAD = f × t − 1, ২৪ বিট−1 বাদ; 72 MHz-এ 250 ms৩৩, ৪৪
Timerf = fTIM ÷ ((PSC + 1)(ARR + 1)), দুটিই ১৬ বিটAPB-এর ×2 ভুলে যাওয়া৪৪
PWMduty = CCR ÷ (ARR + 1); বিট = log2(ARR + 1)CCR ÷ ARR৪৫
UARTBRR = round(f ÷ baud); 8N1 = ১০ বিটশুধু BRR-এর ভুল দেখা৪৯
I2CRp: (VDD − VOL) ÷ IOL থেকে tr ÷ 0.8473Cbtr = RC৫১
ADCLSB = Vref ÷ 2n; integer-এ আগে গুণআগে ভাগ, sign extension ভুলে যাওয়া৪৭, ৫১
Fixed-pointQ×Q-এ বিন্দু যোগ হয়; + অর্ধেক, তারপর shift; saturateছাঁটা, (−1)(−1)৪০
CAN44 + 8n বিট + stuff + IFS 3; ছোট ID জেতেCRC-তে stuffing নেই ভাবা৫২
ModbusCRC নিচের byte আগে; পুরো frame-এর CRC = 00B C4৫৩
RTAR = C + Σ⌈R ÷ Tj⌉Cj, স্থির না হওয়া পর্যন্তU > সীমা = অচল ভাবা৫৬
PowerIavg = Σ I·t ÷ T; derating আগেradio-র burst ছোট করে দেখা৬০, ৬২
নির্ভরযোগ্যতাMTBF = 109 ÷ FIT; A = MTBF ÷ (MTBF + MTTR)MTBF = আয়ু ভাবা৬৩
PIDe = মাপ − setpoint; D মাপ থেকেচিহ্ন উল্টো, Ts ভুলে যাওয়া৬৯
LoRa / MQTTToA-তে preamble + 4.25; 1 % = ToA × 100; ack-এর byteSF বাড়লে শুধু দ্বিগুণ ধরা৭২, ৭৩

১৫ মিনিটের মিনি-সেট — ঘড়ি ধরে করুন

আটটি ছোট প্রশ্ন, প্রতিটিতে দুই মিনিটের মতো। কাগজ-কলম চলবে, চেকার নয়। ৭–৮ ঠিক হলে প্রস্তুত; ৫–৬ হলে সংশ্লিষ্ট অংশ আবার করুন।

  1. 8 MHz-এ 5 ms-এর SysTick tick: LOAD?
  2. 72 MHz-এর timer, PSC 71, ARR 4999: update frequency?
  3. 8 MHz, 9600 baud (১৬ গুণ oversampling): BRR আর ভুল?
  4. ১২ বিটের ADC, 3.3 V, code 2048: ভোল্টেজ?
  5. 0.25-এর Q1.15 মান (দশমিক আর hex)?
  6. তিন task (C, T) = (1, 5), (2, 10), (3, 20): Liu–Layland পরীক্ষা কী বলে?
  7. প্রতি 100 s-এ 1 s ধরে 10 mA, বাকি সময় 20 µA: গড়?
  8. 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-কে দিয়ে পরীক্ষা করানোর একটি কাঠামো:

তুমি এমবেডেড সিস্টেমের একজন কড়া পরীক্ষক। নিচে একটি গাণিতিক প্রশ্ন, প্রশ্নে দেওয়া data (chip, clock, current, সময়) আর আমার উত্তর দিলাম। [প্রশ্ন] [দেওয়া data আর একক] [আমার উত্তর — প্রতিটি ধাপ নম্বর দিয়ে] ১. প্রতিটি ধাপে কোন সূত্র ব্যবহার হয়েছে আর তার উৎস (datasheet, reference manual বা standard) বলো; নিশ্চিত না হলে "নিশ্চিত নই" লেখো। ২. প্রতিটি সংখ্যার একক মিলিয়ে দেখো (mA বনাম µA, ms বনাম µs, dB বনাম dBm). ৩. Register-এর বিট-সীমা, "−1", গোল করার নিয়ম আর overflow আলাদা করে পরীক্ষা করো। ৪. প্রশ্নে যা দেওয়া নেই এমন কোনো chip-এর মান নিজে থেকে বসিয়ো না। ৫. নম্বর-ভাগ বানিয়ে নম্বর দাও, পুরো উত্তর নিজে লিখে দিও না।

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

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

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

ক্রমএকটি battery-চালিত sensor node-এর আয়ু হিসাবের ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. প্রতিটি mode-এর current datasheet থেকে, শর্তসহ, তালিকায় লেখা
  2. এক period-এ প্রতিটি mode কত সময় চলে, ঠিক করা
  3. প্রতিটি সারির I × t যোগ করে মোট charge বের করা
  4. মোট charge-কে period দিয়ে ভাগ করে গড় current পাওয়া
  5. 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

শব্দকোষ

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

মনে রাখুন

  1. Register-এর হিসাব: SysTick LOAD = f × t − 1 (২৪ বিট); timer-এ (PSC + 1)(ARR + 1) = fTIM ÷ f (দুটিই ১৬ বিট); duty = CCR ÷ (ARR + 1); BRR = round(f ÷ baud).
  2. সংখ্যার পথ: LSB = Vref ÷ 2n; integer-এ আগে গুণ, পরে গোল করে ভাগ; ঋণাত্মক sensor-এ sign extension; Q-গুণে অর্ধেক যোগ, shift, saturate.
  3. Bus: UART-এর ভুলের বাজেটে BRR আর clock দুটিই; I2C-এর Rp একটি জানালা; CAN-এ stuff বিট আর IFS; Modbus-এর CRC নিচের byte আগে।
  4. সময়ের প্রমাণ: U ≤ সীমা হলে নিশ্চিত, না হলে RTA; queue-র গভীরতা = ধীর পাঠকের ব্যস্ত সময়ে কয়টি আসে।
  5. System: গড় current সারি ধরে, derating-এর পরে আয়ু; MTBF হার, আয়ু নয়; LoRa-র airtime-এ preamble আর 1 %-এর নিয়ম; int8-এ s আর z.

পরের পর্বে: পর্ব ৮৫ (ইন্টারভিউতে এমবেডেড আর IoT — firmware, C, RTOS আর debugging-এর প্রশ্ন). Ring buffer, debouncer, CRC আর ছোট scheduler হাতে লেখা, আর embedded C-এর কৌশলী প্রশ্নের পরীক্ষিত উত্তর।

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

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