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

I2C — address, ACK, start-stop আর clock stretching

I2C — Addressing, ACK, Start-Stop and Clock Stretching

Taught in Bangla, this lesson covers I2C's open-drain wired-AND bus and sizes pull-up resistors from sink current and rise time (967 to 3541 Ω at 3.3 V, Fast-mode, 100 pF). It decodes a TMP102-style register read with a repeated START, 45 SCL clocks long. On the course's virtual BG-M3 board a cold-room sensor returns 4.00 °C and −0.50 °C, a wrong address 0x49 gives NACK, and counting three NACKs raises SENSOR FAULT. Two's complement conversion, clock stretching, arbitration and stuck-bus recovery follow.

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

  • Open-drain bus কেন, আর bus capacitance ও rise time থেকে pull-up resistor-এর মান হিসাব করা
  • START, STOP, 7-bit address, R/W, ACK, NACK আর repeated START দিয়ে একটি transaction বিট ধরে পড়া আর লেখা
  • TMP102-ধাঁচের sensor-এর pointer register লিখে দুই byte পড়া, আর raw মানকে two's complement থেকে °C-এ নেওয়া
  • কোর্সের virtual board-এ register-level I2C firmware চালানো, NACK ধরা আর sensor fault-কে নিরাপদে সামলানো
  • Clock stretching, arbitration, bus আটকে যাওয়া আর SMBus timeout-এর নিয়ম চেনা

১ · I2C কী — দুটি তারে অনেক chip

আগের দুটি পর্বে দেখেছেন UART দুটি যন্ত্রকে একজোড়া তারে জোড়ে (পর্ব ৪৯), আর SPI প্রতিটি যন্ত্রের জন্য আলাদা chip select চায় (পর্ব ৫০). কিন্তু একটি board-এ যদি একটি তাপমাত্রার sensor, একটি EEPROM, একটি real-time clock আর একটি ছোট display থাকে? প্রতিটির জন্য আলাদা তার টানলে pin ফুরিয়ে যায়। I2C (Inter-Integrated Circuit, উচ্চারণ “আই-টু-সি” বা “আই-স্কয়ার-সি”) এই সমস্যার সমাধান: মাত্র দুটি তার, SDA আর SCL, আর প্রতিটি chip-এর একটি নিজস্ব ঠিকানা। এই পর্বে hex লেখা হবে C-ধাঁচে, 0x48-এর মতো, আর একটি byte-এর বিট লেখা হবে MSB বাঁয়ে।

উপমা — ক্লাসের রোল কল: শিক্ষক একটি রোল নম্বর ডাকেন, পুরো ক্লাস শোনে, কিন্তু শুধু সেই নম্বরের ছাত্র “উপস্থিত” বলে। কেউ সাড়া না দিলে নীরবতা থেকেই শিক্ষক বোঝেন সে আজ নেই। I2C-তে controller (শিক্ষক) একটি ৭ বিটের ঠিকানা ডাকে, সব chip শোনে, আর শুধু মিলে যাওয়া chip SDA তারটি নিচে টেনে “আছি” বলে: এটিই ACK. কেউ না টানলে তার উঁচুই থাকে, আর সেটির নাম NACK. আর ক্লাসের ঘণ্টার মতো তালটা দেয় controller-ই, SCL তারে।

I2C-এর জন্ম Philips-এ। NXP-র I2C-এর বিবরণ UM10204 (rev. 7.0, ১ অক্টোবর ২০২১)-এর revision তালিকায় প্রথম সংস্করণ ১৯৮২ সালের, প্রথম প্রকাশ্য version 1.0 ১৯৯২ সালের আর version 2.0 ১৯৯৮ সালের। এই rev. 7.0-তে একটি পরিবর্তন জানা দরকার: পুরনো “master/slave” শব্দের বদলে এখন “controller/target”. পুরনো বই, datasheet আর বহু পরীক্ষার প্রশ্নে master/slave পাবেন; দুটি একই জিনিস। এই পর্বে controller আর target লেখা হবে।

ছবি ৫১.১ — বাজারঘরের cold room-এর I2C bus

দুটি pull-up, দুটি তার, তিনটি chip; প্রতিটি chip শুধু তার নিচে টানতে পারে

I2C bus: দুটি pull-up, SDA আর SCL, তিনটি chip 3.3 V RpRp SDA SCL MCUcontrollerBG-M3 Sensortarget 0x48TMP102-ধাঁচ EEPROMtarget 0x50(উদাহরণ) কেউ টানলে 0, সবাই ছাড়লে Rp-এর জোরে 1
ছবি ৫১.১ — প্রতিটি chip-এর SDA আর SCL pin open-drain: ভেতরের transistor তারকে ground-এ টানে বা ছেড়ে দেয়, কখনো উঁচুতে ঠেলে না। EEPROM-টি শুধু উদাহরণ; কোর্সের board-এ শুধু sensor আছে।

Bus-এর গতির কয়েকটি ধাপ UM10204-এ সংজ্ঞায়িত, আর পরীক্ষায় এগুলো প্রায়ই আসে:

Modeসর্বোচ্চ bit ratetr (সর্বোচ্চ)Cb (সর্বোচ্চ)মন্তব্য
Standard-mode (Sm)100 kbit/s1000 ns400 pFসবচেয়ে পুরনো, সব chip জানে
Fast-mode (Fm)400 kbit/s300 ns400 pFবেশিরভাগ sensor-এর সাধারণ গতি
Fast-mode Plus (Fm+)1 Mbit/s120 ns550 pFবেশি sink current (20 mA)
High-speed (Hs)3.4 Mbit/sআলাদা নিয়মবিশেষ controller code দিয়ে শুরু
Ultra Fast-mode (UFm)5 Mbit/spush-pullশুধু এক দিকে, ACK নেই

খেয়াল করুন, প্রতিটি সংখ্যা “সর্বোচ্চ”: I2C ধীরে চলতে পারে, এমনকি controller মাঝপথে থেমেও থাকতে পারে, কারণ clock controller-ই দেয়। UART-এর মতো দুই পক্ষকে আগে থেকে একই baud rate জানতে হয় না। বাজারঘরের cold room-এর sensor প্রতি সেকেন্ডে একবার পড়া হয় (README-র নিয়ম), তাই 100 kHz-ই যথেষ্টের চেয়ে অনেক বেশি।

২ · Open-drain আর pull-up — wired-AND থেকে resistor-এর হিসাব

পর্ব ৪১-এ দেখেছেন open-drain output শুধু 0-তে টানতে পারে, 1 আসে বাইরের pull-up resistor থেকে, আর এমন কয়েকটি output এক তারে জুড়লে তারটি wired-AND হয়। সেখানকার ব্যাখ্যা আবার না বলে শুধু I2C-এর প্রশ্নটি দেখি: কেন push-pull নয়? কারণ I2C-এর SDA-তে কথা বলে কখনো controller, কখনো target, আর ACK-এর মুহূর্তে দুজনের মধ্যে দায়িত্ব বদলায়। Push-pull হলে কোনো মুহূর্তে একজন 1 আর আরেকজন 0 ঠেললে সরাসরি short circuit. Open-drain-এ সবচেয়ে খারাপ ক্ষেত্রেও শুধু resistor দিয়ে একটি ছোট current যায়, আর তারের মান সবসময় নির্দিষ্ট: কেউ টানলে 0.

দাম একটিই: 1-এ ওঠা ধীর। Transistor ছেড়ে দিলে তারটি resistor দিয়ে চার্জ হয়, আর তারের, pin-এর আর PCB-র মোট bus capacitance Cb সেই চার্জ হওয়াকে RC-র মতো দেরি করায়। UM10204 §7.1 rise time-কে মাপে 0.3 VDD থেকে 0.7 VDD পর্যন্ত, যা RC চার্জের সূত্রে t = RC × ln(0.7 ÷ 0.3) = 0.8473 RC. এখান থেকে resistor-এর দুই সীমা:

Pull-up-এর জানালা (UM10204 §7.1)

১. Rp(max) = tr ÷ (0.8473 × Cb) — বড় resistor হলে rise time সীমা ছাড়ায়
২. Rp(min) = (VDD − VOL(max)) ÷ IOL — ছোট resistor হলে pin যথেষ্ট নিচে টানতে পারে না; Sm/Fm-এ VOL = 0.4 V at 3 mA, Fm+-এ 20 mA
৩. Rp(min) ≤ Rp ≤ Rp(max) হতে হবে; জানালা না থাকলে bus ভাগ বা buffer লাগে

নিচের ব্লক এই দুটি সূত্র কয়েকটি Cb-এ চালায়, তারপর বাজারঘরের একটি ছোট bus-এর জন্য তিনটি প্রচলিত resistor পরখ করে:

# I2C pull-up: Rp(min) আসে sink current থেকে, Rp(max) আসে rise time থেকে (UM10204 §7.1)
import math
VDD, VOL = 3.3, 0.4                       # VOL(max) 0.4 V
k = math.log(0.7 / 0.3)                   # 0.3·VDD থেকে 0.7·VDD ওঠার সময় = k·RC
print(f"k = ln(0.7/0.3) = {k:.4f}")
modes = {"Standard 100k": (1000e-9, 3e-3), "Fast 400k": (300e-9, 3e-3),
         "Fast+ 1M": (120e-9, 20e-3)}     # (tr max, IOL)
for cb in (50e-12, 100e-12, 200e-12, 400e-12):
    row = []
    for name, (tr, iol) in modes.items():
        rmin = (VDD - VOL) / iol
        rmax = tr / (k * cb)
        ok = "ঠিক" if rmax >= rmin else "অসম্ভব"
        row.append(f"{rmin:5.0f}–{rmax:6.0f} Ω {ok}")
    print(f"Cb {cb * 1e12:3.0f} pF │ " + " │ ".join(row))

# বাজারঘর board-এর bus: ৩টি chip × 10 pF pin + 30 cm তার (ধরা যাক 50 pF/m)
cb = 3 * 10e-12 + 0.30 * 50e-12 + 10e-12  # শেষ 10 pF: MCU-র নিজের pin
for rp in (2_200, 4_700, 10_000):
    tr = k * rp * cb
    i = (VDD - VOL) / rp
    print(f"Rp {rp / 1000:4.1f} kΩ, Cb {cb * 1e12:.0f} pF: tr = {tr * 1e9:4.0f} ns,"
          f" LOW-এ current {i * 1e3:.2f} mA")

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

k = ln(0.7/0.3) = 0.8473
Cb  50 pF │   967– 23604 Ω ঠিক │   967–  7081 Ω ঠিক │   145–  2833 Ω ঠিক
Cb 100 pF │   967– 11802 Ω ঠিক │   967–  3541 Ω ঠিক │   145–  1416 Ω ঠিক
Cb 200 pF │   967–  5901 Ω ঠিক │   967–  1770 Ω ঠিক │   145–   708 Ω ঠিক
Cb 400 pF │   967–  2951 Ω ঠিক │   967–   885 Ω অসম্ভব │   145–   354 Ω ঠিক
Rp  2.2 kΩ, Cb 55 pF: tr =  103 ns, LOW-এ current 1.32 mA
Rp  4.7 kΩ, Cb 55 pF: tr =  219 ns, LOW-এ current 0.62 mA
Rp 10.0 kΩ, Cb 55 pF: tr =  466 ns, LOW-এ current 0.29 mA

প্রথম লাইন UM10204-এর ধ্রুবকটি নিজে বের করেছে: 0.8473. তারপর টেবিল: Cb যত বাড়ে, Rp(max) তত কমে, কিন্তু Rp(min) একই থাকে। 3.3 V-এ Fast-mode আর 400 pF-এ জানালা বন্ধ (967 > 885): কোনো resistor-ই চলবে না, যদিও 400 pF Fast-mode-এর অনুমোদিত সীমা। Fm+ সেখানে বাঁচে, কারণ তার pin 20 mA টানতে পারে। শেষ তিন লাইন বাজারঘরের ছোট bus (আনুমানিক 55 pF; আসল মান PCB আর তার মেপে বা হিসাব করে নিতে হয়)। 10 kΩ-এ rise time 466 ns, যা 100 kHz-এর 1000 ns সীমায় চলে কিন্তু 400 kHz-এর 300 ns সীমা ছাড়ায়। “সব জায়গায় 10 kΩ” তাই ধীর bus-এ চলে, দ্রুত bus-এ নয়।

পরীক্ষার ধাঁচের উদাহরণ: VDD = 3.3 V, Fast-mode, আনুমানিক Cb = 100 pF. Pull-up কত নেবেন?

  1. Rp(min) = (3.3 − 0.4) V ÷ 3 mA = 967 Ω.
  2. Rp(max) = 300 ns ÷ (0.8473 × 100 pF) = 3541 Ω.
  3. জানালা 967 Ω থেকে 3541 Ω. 3.3 kΩ নিলে tr = 0.8473 × 3.3 kΩ × 100 pF = 280 ns, সীমার খুব কাছে; 2.2 kΩ নিলে 186 ns, হাতে ভালো জায়গা থাকে।
  4. 2.2 kΩ-এ LOW-এর সময় প্রতিটি তারে (3.3 − 0.4) ÷ 2.2 kΩ = 1.32 mA, যা 3 mA-এর অনেক নিচে। ব্যাটারির যন্ত্রে বড় resistor (জানালার ওপরের দিকে) current কমায়; UM10204-ও সেই পরামর্শ দেয়।

দুটি সাধারণ ভুল: এক, প্রতিটি breakout module-এ নিজের pull-up থাকে; পাঁচটি module একসাথে জুড়লে পাঁচটি 10 kΩ সমান্তরালে 2 kΩ, আর আরও বেশি হলে Rp(min)-এর নিচে নেমে যেতে পারে। দুই, MCU-র ভেতরের pull-up (প্রায়ই কয়েক দশ kΩ-এর ঘরে; আপনার chip-এর datasheet দেখুন) শুধু খুব ধীর, খুব ছোট bus-এ চলে। আর 5 V আর 3.3 V-এর chip এক bus-এ রাখতে হলে level shifter লাগে; pull-up কোন voltage-এ বাঁধা, তা দুই পাশের chip-এর input-এর সহনশীলতা মিলিয়ে ঠিক করুন।

৩ · Frame — START, STOP, ঠিকানা, R/W আর ACK

দুটি তারে সব নিয়ম বোঝাতে I2C একটি চতুর কৌশল ব্যবহার করে। সাধারণ data বিটের সময় SDA বদলায় শুধু SCL নিচু থাকলে, আর SCL উঁচু থাকলে SDA স্থির থাকে; তখনই receiver বিটটি পড়ে। তাই SCL উঁচু অবস্থায় SDA বদলানো “নিষিদ্ধ”, আর ঠিক সেই নিষিদ্ধ ঘটনা দুটিকে বিশেষ সংকেত বানানো হয়েছে (UM10204 §3.1.4):

  • START (S): SCL উঁচু থাকা অবস্থায় SDA 1 থেকে 0-তে নামে। Bus এখন ব্যস্ত।
  • STOP (P): SCL উঁচু থাকা অবস্থায় SDA 0 থেকে 1-এ ওঠে। কিছু সময় পরে bus আবার মুক্ত।
  • Repeated START (Sr): STOP না দিয়েই আবার একটি START. Bus controller-এর হাতেই থাকে, অন্য কেউ ঢুকতে পারে না।

START-এর পরে প্রথম byte সবসময় ঠিকানার: ৭ বিটের target address, তারপর একটি R/W বিট (0 = লেখা, 1 = পড়া)। প্রতিটি byte ৮ বিটের, MSB আগে, আর প্রতিটির পরে ৯ নম্বর clock-এ একটি ACK বিট: যে byte পেল, সে SDA নিচে টেনে ACK দেয়; টানলে না NACK. Clock সবসময় controller দেয়, ACK-এর ৯ নম্বর clock-ও।

ছবি ৫১.২ — START আর প্রথম byte: ঠিকানা 0x48, লেখা (W), sensor-এর ACK

SDA বদলায় SCL নিচু থাকলে; SCL-এর উঁচু অংশে বিটটি পড়া হয়

START, ঠিকানা 0x48, W, ACK-এর waveform SCLSDA S 100100000 A6A5A4A3A2A1A0WACK ঠিকানা 1001000 = 0x48 পুরো byte 0x90 (0x48 << 1 | W) ACK (সবুজ) দেয় sensor
ছবি ৫১.২ — নীল দাগের অংশে (SCL উঁচু) SDA স্থির, receiver তখন বিট পড়ে। START-এ SDA নেমেছে SCL উঁচু থাকতেই, যা data বিটে কখনো ঘটে না। ৯ নম্বর clock-এ controller SDA ছেড়ে দেয় আর sensor নিচে টেনে রাখে।

ঠিকানা আর R/W মিলে এক byte হয় বলে datasheet আর code-এ দুই রূপ দেখবেন: ৭ বিটের ঠিকানা 0x48, আর byte-এর রূপে 0x90 (লেখা) বা 0x91 (পড়া), অর্থাৎ (0x48 << 1) | R/W. কিছু library ৭ বিটের রূপ চায়, কিছু ৮ বিটের; ভুল রূপ দিলে chip সাড়া দেয় না, আর এটি নতুনদের সবচেয়ে সাধারণ I2C ভুল (অনুশীলন ২).

কয়েকটি ঠিকানা সংরক্ষিত (UM10204 Table 4): 0000 XXX আর 1111 XXX-এর দুই দল। যেমন 0000 000 + W = general call (সবার উদ্দেশে), 0000 1XX = Hs-mode-এর controller code, 1111 0XX = ১০ বিটের ঠিকানার শুরু। তাই সাধারণ chip-এর ঠিকানা 0x08 থেকে 0x77-এর মধ্যে থাকে। একই chip এক bus-এ কয়েকটি রাখতে নির্মাতারা ঠিকানার কয়েকটি বিট pin দিয়ে বাছার সুযোগ দেন। TI-র TMP102 datasheet (SBOS397I) অনুযায়ী ADD0 pin ground-এ জুড়লে ঠিকানা 1001000 (0x48), V+-এ 0x49, SDA-তে 0x4A, SCL-এ 0x4B: চারটি sensor এক bus-এ।

NACK কখন হয়? UM10204 §3.1.6 পাঁচটি কারণ বলে: ঠিকানায় কেউ নেই; receiver ব্যস্ত; receiver এমন data পেল যা সে বোঝে না; receiver আর byte নিতে পারে না; আর পড়ার শেষে controller নিজেই NACK দিয়ে target-কে জানায় “আর না”। শেষেরটি ভুল নয়, নিয়ম। NACK-এর পরে controller STOP দিয়ে থামে বা repeated START দিয়ে নতুন transaction শুরু করে।

৪ · একটি register পড়া — pointer, repeated START আর দুই byte

বেশিরভাগ I2C sensor-এর ভেতরে কয়েকটি register থাকে, আর কোনটি পড়বেন তা ঠিক করে একটি register pointer. TMP102 datasheet-এর Table 6-7 অনুযায়ী pointer 0x00 = temperature (শুধু পড়া), 0x01 = configuration, 0x02 = TLOW, 0x03 = THIGH. পড়ার নিয়ম দুই ধাপে (datasheet §6.3.5):

  1. Pointer লেখা: START, ঠিকানা + W, তারপর pointer byte. আর কোনো data নয়।
  2. পড়া: repeated START, ঠিকানা + R, তারপর target দুই byte পাঠায়, MSB আগে। Controller প্রথম byte-এ ACK দেয় (“আরও চাই”), শেষ byte-এ NACK (“আর না”), তারপর STOP.

একটি সুবিধাও datasheet-এ আছে: TMP102 শেষ pointer মনে রাখে, আর power-up-এ pointer 00. তাই একই register বারবার পড়লে প্রতিবার pointer লিখতে হয় না; শুধু দ্বিতীয় ধাপই যথেষ্ট। নিচের ব্লক পুরো transaction-এর বিট বানায় আর clock গোনে, একটি সঠিক ঠিকানায় আর একটি ভুল ঠিকানায়:

# TMP102-ধাঁচের register read: pointer লেখা, repeated START, ২ byte পড়া
def bits(b):
    return "".join(str((b >> i) & 1) for i in range(7, -1, -1))   # MSB আগে

def read_reg(addr, reg, present, data=0x0400):
    log, clocks = ["S"], 0
    def byte(b, ack):                    # ack: 'A' = SDA টানা (0), 'N' = ছাড়া (1)
        nonlocal clocks
        clocks += 9                      # ৮টি data বিট + ৯ নম্বর ACK বিট
        log.append(f"{b:02X}:{bits(b)}/{ack}")
    if not present:                      # ঠিকানায় কেউ নেই: SDA উঁচু থাকে
        byte(addr << 1 | 0, "N")
        return log + ["P"], clocks
    byte(addr << 1 | 0, "A")             # ঠিকানা + W, sensor-এর ACK
    byte(reg, "A")                       # pointer byte, sensor-এর ACK
    log.append("Sr")                     # STOP নয়: repeated START
    byte(addr << 1 | 1, "A")             # ঠিকানা + R, sensor-এর ACK
    byte(data >> 8, "A")                 # sensor পাঠায় MSB, MCU-র ACK
    byte(data & 0xFF, "N")               # শেষ byte: MCU-র NACK = "আর না"
    return log + ["P"], clocks

for addr, present in ((0x48, True), (0x49, False)):
    log, clocks = read_reg(addr, 0x00, present)
    print(f"ঠিকানা 0x{addr:02X}:", " ".join(log))
    for khz in (100, 400):
        print(f"   {clocks} SCL clock, {khz} kHz-এ ≈ {clocks / khz * 1000:.1f} µs"
              " (START/STOP-এর সময় বাদে)")
print("0x48<<1 =", hex(0x48 << 1), " 0x48<<1|1 =", hex(0x48 << 1 | 1))

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

ঠিকানা 0x48: S 90:10010000/A 00:00000000/A Sr 91:10010001/A 04:00000100/A 00:00000000/N P
   45 SCL clock, 100 kHz-এ ≈ 450.0 µs (START/STOP-এর সময় বাদে)
   45 SCL clock, 400 kHz-এ ≈ 112.5 µs (START/STOP-এর সময় বাদে)
ঠিকানা 0x49: S 92:10010010/N P
   9 SCL clock, 100 kHz-এ ≈ 90.0 µs (START/STOP-এর সময় বাদে)
   9 SCL clock, 400 kHz-এ ≈ 22.5 µs (START/STOP-এর সময় বাদে)
0x48<<1 = 0x90  0x48<<1|1 = 0x91

সঠিক ঠিকানায় পাঁচটি byte, প্রতিটি ৯ clock: ৪৫টি SCL clock. 100 kHz-এ প্রায় 450 µs, আর প্রতি সেকেন্ডে একবার পড়লে bus সময়ের মাত্র ০.০৪৫% ব্যস্ত। দুই byte-এর data 0x04 0x00, যা পরের অংশে দেখবেন 4.00 °C. ভুল ঠিকানা 0x49-এ (byte 0x92) প্রথম byte-এর ৯ নম্বর clock-এ কেউ SDA টানেনি, তাই NACK, আর controller সেখানেই STOP দিয়েছে: ৯ clock, 90 µs. এই হিসাবে START, STOP আর repeated START-এর setup ও hold সময় ধরা হয়নি; UM10204-এর Table 11 সেগুলো দেয় (যেমন Standard-mode-এ STOP আর পরের START-এর মাঝে অন্তত 4.7 µs).

Bus-এ এখন
অংশ
SDA-তে
কে SDA চালায়
মোট SCL clock
মানে
  1. START. SCL উঁচু থাকতেই MCU SDA নামায়। সব target এখন ঠিকানা শোনার জন্য তৈরি।
  2. ঠিকানা + W. ৮টি clock-এ 1001000 আর R/W = 0: byte 0x90. প্রতিটি বিট SCL নিচু থাকতে বসে, উঁচু থাকতে পড়া হয়।
  3. ACK. ৯ নম্বর clock-এ MCU SDA ছেড়ে দেয়; ঠিকানা মেলায় sensor তারটি নিচে টানে। কেউ না টানলে এখানেই NACK আর STOP হতো।
  4. Pointer. MCU পাঠায় 0x00 = temperature register; sensor আবার ACK দেয়। মোট ১৮ clock.
  5. Repeated START. STOP না দিয়ে আবার START: bus অন্য controller-এর হাতে যায় না, আর sensor-এর pointer যেমন ছিল তেমনই থাকে।
  6. ঠিকানা + R. এবার 0x91, R/W = 1. Sensor ACK দেয়, আর এখন থেকে data-র দিক উল্টো: sensor পাঠাবে।
  7. MSB. Sensor পাঠায় 0x04; MCU এবার receiver, তাই MCU-ই SDA টেনে ACK দেয়: “আরও একটি byte চাই”।
  8. LSB আর NACK. Sensor পাঠায় 0x00; MCU SDA ছেড়ে রাখে: NACK, মানে “যথেষ্ট”। এটি ভুল নয়, নিয়ম। মোট ৪৫ clock.
  9. STOP. SCL উঁচু থাকতে SDA ওঠে; bus মুক্ত। পাওয়া দুই byte 0x04 0x00 = 0x0400, যা ১২ বিটের 64, অর্থাৎ 4.00 °C.

৫ · বাজারঘর board-এ সত্যিকারের run — sensor পড়া আর NACK

কোর্সের বাজারঘর board (BG-M3) একটি virtual Cortex-M3, আসল কোনো পণ্য নয় (পর্ব ০৬). এর memory map-এ 0x40005400-এ একটি “I2C-ধাঁচের” bus আছে, আর তাতে cold room-এর TMP102-ধাঁচের sensor, ঠিকানা 0x48. প্রথমেই সৎভাবে বলা দরকার এটি কী মডেল করে আর কী করে না।

Board-এর সীমা (reference lab, Spec decision 26): I2C এখানে register-level: firmware ADDR (0x08) আর REG (0x0C) লিখে CR-এ START বিট (0x00, বিট 0) দিলে board একবারে “pointer লেখা + দুই byte পড়া” শেষ করে, SR-এ DONE (বিট 0) বসায় আর DATA-তে (0x10) ১৬ বিটের ফল দেয়, প্রথম byte বিট 15–8-এ। SDA/SCL-এর waveform, START/STOP/ACK-এর বিট-সময়, clock stretching বা bus-এর গতি মডেল করা হয়নি. শুধু 0x48 সাড়া দেয়; অন্য যেকোনো ঠিকানায় SR-এ DONE আর NACK (বিট 1) দুটিই বসে আর DATA = 0xFFFF. Sensor শুধু register 0x00 জানে; অন্য register পড়লে 0 আসে (আসল TMP102-এর configuration register-এর power-up মান 0x60A0, datasheet-এর Table 6-10 আর 6-11). তাই বিট-স্তরের সব কথা এই পর্বে Python মডেলে আর UM10204 থেকে, আর firmware-স্তরের কথা board-এ।

আমার lab-এর i2c_demo.c প্রতি 100 ms-এ sensor পড়ে, script ঘরের তাপমাত্রা বদলায়, আর শেষে দুটি ভুল পড়া করে: ঠিকানা 0x49 আর register 0x01. মূল অংশ (reference-এর coldroom.c-এর tsens_read() থেকে বানানো, একটি timeout যোগ করে):

/* pointer write + 2-byte read (the board does both on START) */
static uint32_t i2c_read16(uint32_t addr, uint32_t reg, uint32_t *data)
{
    uint32_t sr, spins = 0;
    I2C1->ADDR = addr;                   /* 7-bit address, not 0x90 */
    I2C1->REG = reg;
    I2C1->CR = I2C_CR_START;
    while (((sr = I2C1->SR) & (I2C_SR_DONE | I2C_SR_NACK)) == 0) {
        if (++spins > 10000u)
            return 0xFFu;                  /* timeout: never hang on a stuck bus */
    }
    *data = I2C1->DATA;
    return sr;
}

static void show(uint32_t addr, uint32_t reg)
{
    uint32_t d = 0, sr = i2c_read16(addr, reg, &d);
    /* ... print addr, reg, SR ... */
    if (sr & I2C_SR_NACK) { /* print "NACK DATA=..." */ return; }
    int32_t t16 = (int32_t)(int16_t)d >> 4;   /* 12-bit two's complement */
    /* ... print MSB, LSB, t16 and t16 * 25 / 4 as hundredths ... */
}
সত্যিকারের run — board.py run build/i2c_demo.elf --script demo.json (BG-M3, Clang 22.1.8 -O2)
[     0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[     0.0000 ms] > cold-room temperature: +4.00 C
[   100.0859 ms] UART: addr=0x48 reg=0x00 SR=0x1 MSB=0x04 LSB=0x00 t16=64 T=4.00 C
[   150.0000 ms] > cold-room temperature: -0.50 C
[   200.0854 ms] UART: addr=0x48 reg=0x00 SR=0x1 MSB=0xFF LSB=0x80 t16=-8 T=-0.50 C
[   250.0000 ms] > cold-room temperature: -25.00 C
[   300.0919 ms] UART: addr=0x48 reg=0x00 SR=0x1 MSB=0xE7 LSB=0x00 t16=-400 T=-25.00 C
[   350.0000 ms] > cold-room temperature: +8.25 C
[   400.0881 ms] UART: addr=0x48 reg=0x00 SR=0x1 MSB=0x08 LSB=0x40 t16=132 T=8.25 C
[   450.0000 ms] > cold-room temperature: +0.06 C
[   500.0839 ms] UART: addr=0x48 reg=0x00 SR=0x1 MSB=0x00 LSB=0x10 t16=1 T=0.06 C
[   550.0000 ms] > cold-room temperature: +7.80 C
[   600.0881 ms] UART: addr=0x48 reg=0x00 SR=0x1 MSB=0x07 LSB=0xD0 t16=125 T=7.81 C
[   600.1392 ms] UART: addr=0x49 reg=0x00 SR=0x3 NACK DATA=0xFFFF
[   600.2179 ms] UART: addr=0x48 reg=0x01 SR=0x1 MSB=0x00 LSB=0x00 t16=0 T=0.00 C
[   600.2186 ms] exit(0) after 4801749 cycles

প্রতিটি লাইন README-র বর্ণনার সঙ্গে মেলে: 4.00 °C = 0x0400, −0.50 °C = 0xFF80, −25 °C = 0xE700. দুটি লাইন বিশেষভাবে দেখুন। 0.0625 °C-এর script মান board-এর নিজের লাইনে “+0.06 C” হিসেবে ছাপা (দুই দশমিকে গোল করা), আর firmware-ও 0.06 দেখায়, যদিও আসলে 0.0625. 7.80 °C-কে sensor 1/16 °C-এর ধাপে নিয়েছে: 7.80 × 16 = 124.8 → 125 = 7.8125 °C, আর firmware ছেপেছে 7.81. পরের অংশে এই গোল করা আর কাটার পার্থক্য খুঁজব। আর (int32_t)(int16_t) দিয়ে sign extension কেন, তা পর্ব ০৫-এ এই sensor দিয়েই দেখানো হয়েছিল।

NACK চুপচাপ এড়িয়ে গেলে কী হয়

এবার একটি বাস্তব ভুল ঘটাই। ধরা যাক PCB-তে sensor-এর ADD0 pin ground-এর বদলে V+-এ জোড়া, তাই আসল ঠিকানা 0x49, অথচ firmware ডাকে 0x48 (বা উল্টো)। আমি reference-এর coldroom.c হুবহু রেখে শুধু ঠিকানাটি 0x49 করে চালিয়েছি, README-র একই cold-room script দিয়ে, প্রথম তিন সেকেন্ড:

সত্যিকারের run — coldroom.c, ঠিকানা 0x49 (একটি লাইন বদলানো), --cycles 24000000
[     0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[     0.0000 ms] > cold-room temperature: +4.00 C
[     0.0600 ms] UART: cold-room monitor: limits 0.00 .. 8.00 C, hysteresis 0.50 C, confirm 3
[  1000.0186 ms] UART: sensor NACK
[  2000.0186 ms] UART: sensor NACK
[  2500.0000 ms] > cold-room temperature: +5.50 C
[  3000.0000 ms] stopped: cycle limit (24000000) reached after 24000000 cycles

Reference firmware NACK পেলে শুধু “sensor NACK” ছাপে আর পরের সেকেন্ডে আবার চেষ্টা করে। শেখার জন্য ঠিক আছে, কিন্তু আসল cold room-এ এটি বিপজ্জনক: sensor চুপ থাকলে তাপমাত্রা 9.50 °C-এ উঠলেও alarm কখনো বাজবে না, কারণ alarm-এর গোনা শুধু সফল পড়ায় চলে। আরও খারাপ একটি ভুল হলো NACK না দেখে DATA পড়ে ফেলা: 0xFFFF-কে ১২ বিটের two's complement ধরলে −1, অর্থাৎ −0.0625 °C, একটি সম্পূর্ণ বিশ্বাসযোগ্য তাপমাত্রা (পরের অংশের ব্লকে দেখবেন)। আমার lab-এর coldroom_fault.c তাই একটি নিয়ম যোগ করে: পরপর তিনবার NACK হলে (README-র একই “৩ বার” নিয়ম) PA6 চালু আর “SENSOR FAULT”:

সত্যিকারের run — coldroom_fault.c (ঠিকানা 0x49 + NACK গোনা), --cycles 32000000
[  1000.0186 ms] UART: sensor NACK
[  2000.0186 ms] UART: sensor NACK
[  2500.0000 ms] > cold-room temperature: +5.50 C
[  3000.0186 ms] UART: sensor NACK
[  3000.0199 ms] GPIO PA6 ALARM ON
[  3000.0392 ms] UART: ALARM ON: SENSOR FAULT
[  4000.0000 ms] stopped: cycle limit (32000000) reached after 32000000 cycles

এখন sensor হারালে তিন সেকেন্ডের মধ্যে দোকানদার জানেন। নীতিটি সাধারণ: মাপতে না পারাও একটি alarm-এর অবস্থা। আর অপেক্ষার loop-এ timeout রাখুন; ওপরের i2c_read16()-এর spins গোনা না থাকলে আসল chip-এ আটকে যাওয়া bus পুরো firmware আটকে দিত, আর তখন শুধু watchdog বাঁচাত (পর্ব ৬১). এই অপেক্ষাটি একটি busy-wait polling; আসল I2C peripheral-এ সাধারণত interrupt বা DMA দিয়ে CPU মুক্ত রাখা হয় (পর্ব ৪৩, পর্ব ৪৬)।

৬ · Raw থেকে °C — two's complement, ১২ বিট আর গোল করা

TMP102 datasheet (§6.3.1) অনুযায়ী temperature register ১২ বিটের, বাঁ-ঘেঁষা (left-justified): প্রথম byte (MSB)-এর ৮ বিট আর দ্বিতীয় byte-এর ওপরের ৪ বিট, নিচের ৪ বিট normal mode-এ 0. এক ধাপ 0.0625 °C, আর ঋণাত্মক মান two's complement-এ। তাই রূপান্তর তিন ধাপের:

দুই byte → °C

১. raw = (MSB << 8) | LSB (MSB আগে আসে)
২. t16 = raw-কে signed ১৬ বিট ধরে 4 বিট ডানে (arithmetic shift): (int16_t)raw >> 4 — sign extension সহ
৩. °C = t16 × 0.0625 = t16 ÷ 16; float ছাড়া শতাংশে: t16 × 25 ÷ 4

t16 আসলে একটি fixed-point সংখ্যা: ৪টি ভগ্নাংশ বিট, অর্থাৎ পর্ব ৪০-এর ভাষায় Q12.4 ধরনের Q format. সেখানে এই sensor-এর word-কে কেন Q8.8 থেকে Q12.4-এ নেওয়া হয়, তাও দেখানো। এখানে প্রশ্নটি ছাপার: t16 * 25 / 4-এর C-ভাগ শূন্যের দিকে কাটে। নিচের ব্লক board-এর run-এর byte-গুলো আর কয়েকটি কৌশলী মান রূপান্তর করে:

# TMP102-ধাঁচের দুই byte → °C (১২ বিট two's complement, 0.0625 °C/LSB)
def t16_from(msb, lsb):
    raw = msb << 8 | lsb                       # MSB আগে আসে
    t = raw >> 4                               # ১২ বিট, বাঁ-ঘেঁষা
    return t - 4096 if t & 0x800 else t        # sign extension

def c_div(a, b):                               # C-র ভাগ: শূন্যের দিকে কাটে
    q = abs(a) // abs(b)
    return q if (a >= 0) == (b >= 0) else -q

def show(msb, lsb):
    t = t16_from(msb, lsb)
    exact = t * 0.0625
    trunc = c_div(t * 25, 4)                   # board-এর firmware: t16*25/4
    rnd = c_div(t * 25 + (2 if t >= 0 else -2), 4)   # অর্ধেক শূন্য থেকে দূরে
    print(f"0x{msb:02X} 0x{lsb:02X} → t16 = {t:5}  আসল {exact:+9.4f} °C"
          f"  t16*25/4 = {trunc / 100:+.2f}  গোল = {rnd / 100:+.2f}")

for m, l in ((0x04, 0x00), (0xFF, 0x80), (0xE7, 0x00), (0x08, 0x40),
             (0x07, 0xD0), (0x00, 0x30), (0xFF, 0xD0), (0x7F, 0xF0)):
    show(m, l)
print("ভুল sign:", (0xFF80 >> 4) * 0.0625, "°C (sign extension ছাড়া)")
print("NACK-এর DATA 0xFFFF পড়লে:", t16_from(0xFF, 0xFF) * 0.0625, "°C")

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

0x04 0x00 → t16 =    64  আসল   +4.0000 °C  t16*25/4 = +4.00  গোল = +4.00
0xFF 0x80 → t16 =    -8  আসল   -0.5000 °C  t16*25/4 = -0.50  গোল = -0.50
0xE7 0x00 → t16 =  -400  আসল  -25.0000 °C  t16*25/4 = -25.00  গোল = -25.00
0x08 0x40 → t16 =   132  আসল   +8.2500 °C  t16*25/4 = +8.25  গোল = +8.25
0x07 0xD0 → t16 =   125  আসল   +7.8125 °C  t16*25/4 = +7.81  গোল = +7.81
0x00 0x30 → t16 =     3  আসল   +0.1875 °C  t16*25/4 = +0.18  গোল = +0.19
0xFF 0xD0 → t16 =    -3  আসল   -0.1875 °C  t16*25/4 = -0.18  গোল = -0.19
0x7F 0xF0 → t16 =  2047  আসল +127.9375 °C  t16*25/4 = +127.93  গোল = +127.94
ভুল sign: 255.5 °C (sign extension ছাড়া)
NACK-এর DATA 0xFFFF পড়লে: -0.0625 °C

প্রথম পাঁচটি লাইন board-এর run-এর সঙ্গে হুবহু মেলে। 0.1875 °C-এ firmware-এর ভাগ 18.75 শতাংশকে 18 করে, সঠিক গোল 19; README-ও বলে এই ছাপা 0.25 °C-এর গুণিতকে নিখুঁত, অন্য মানে শূন্যের দিকে কাটে। ঋণাত্মক দিকেও কাটা শূন্যের দিকে (−0.18), তাই ভুল সবসময় ছোট আর প্রতিসম, এক ধাপের এক-চতুর্থাংশের কম। Alarm-এর সিদ্ধান্ত এতে বদলায় না, কারণ firmware তুলনা করে t16-এর পূর্ণসংখ্যায়, ছাপা মানে নয়। শেষ দুই লাইন দুটি বিপদ: sign extension ভুলে গেলে −0.50 °C হয়ে যায় 255.5 °C, আর NACK না দেখে 0xFFFF পড়লে −0.0625 °C, যা দেখতে একদম স্বাভাবিক।

Cold room-এর সীমাগুলোও firmware রাখে t16-এর এককে (reference-এর coldroom.c): HIGH = 8 × 16 = 128, LOW = 0, hysteresis 0.50 °C = 8. তাই alarm-এর নিয়ম: t16 > 128 তিনবার পরপর হলে HIGH, t16 < 0 তিনবার পরপর হলে LOW, আর 8 ≤ t16 ≤ 120 (0.50 … 7.50 °C) তিনবার পরপর হলে alarm বন্ধ। এই hysteresis-এর বর্ণনা README-র “বাজারঘর devices” অংশে:

একটি পড়া
MSB, LSB
১২ বিটের অংশ
t16 (signed)
°C (t16 ÷ 16)
Firmware ছাপে
Alarm-এর হিসাবে
  1. 4.00 °C. 0x0400-এর ওপরের ১২ বিট 0x040 = 64; 64 ÷ 16 = 4. MSB-এর বিট 7 শূন্য, তাই ধনাত্মক।
  2. −0.50 °C. 0xFF8-এর বিট 11 = 1, তাই ঋণাত্মক: 4088 − 4096 = −8, আর −8 ÷ 16 = −0.5. C-তে (int16_t) cast আর arithmetic shift এই বিয়োগটাই করে।
  3. −25 °C. 0xE70 = 3696; 3696 − 4096 = −400; −400 × 0.0625 = −25. Datasheet-এর নিজের উদাহরণও 1110 0111 0000 = −25 °C.
  4. 7.80 °C-এর ঘর। Sensor 1/16 °C-এর ধাপে মাপে: 125 = 7.8125 °C. এটি 7.50-এর ওপরে আর 8.00-এর নিচে, তাই HIGH-ও নয়, “ঠিক”-ও নয়: hysteresis-এর ফাঁক, যেখানে কোনো গোনা বাড়ে না।
  5. 0.1875 °C আর ছাপার কাটা। 3 × 25 = 75, 75 ÷ 4 = 18 (C-ভাগ), তাই “0.18”. সঠিক গোল 0.19. মানটি 0.00 থেকে 0.50-এর ফাঁকে, LOW নয়, “ঠিক”-ও নয়।

TMP102-এর একটি বাড়তি mode-ও আছে, extended mode (configuration-এর EM বিট = 1): তখন register ১৩ বিটের, যাতে 128 °C-এর ওপরের মানও ধরা যায়, আর দ্বিতীয় byte-এর D0 বিট বলে কোন mode চলছে (datasheet §6.3.1, §6.4.2). কোর্সের board শুধু ১২ বিটের normal mode মডেল করে।

৭ · Clock stretching, arbitration আর আটকে যাওয়া bus

Wired-AND-এর সবচেয়ে সুন্দর ফল এই অংশে। SCL-ও open-drain, তাই controller clock উঁচু করতে চাইলেও কোনো target তা নিচে ধরে রাখতে পারে। এর নাম clock stretching: “একটু দাঁড়ান, আমি এখনও তৈরি নই”। UM10204 §3.1.9 বলে এটি ঐচ্ছিক, আর বেশিরভাগ target-এ SCL চালানোর driver-ই নেই। TMP102-ও SCL কখনো চালায় না (datasheet §6.3.6). তাই controller-এর I2C hardware বা bit-bang code-কে SCL ছেড়ে দেওয়ার পরে তারটি সত্যিই উঁচু হলো কি না দেখে তবেই এগোতে হয়; যে driver এটি দেখে না, সে stretching করা target-এর সঙ্গে ভুল বিট পড়ে।

দুই controller একই bus-এ থাকলে আরেক প্রশ্ন: দুজন একই সঙ্গে START দিলে কে জিতবে? I2C-এ কোনো কেন্দ্রীয় বিচারক নেই। প্রতিটি controller প্রতিটি বিট পাঠানোর পরে SCL উঁচু থাকতে SDA পড়ে দেখে। যে 1 পাঠিয়ে তারে 0 দেখে, সে বোঝে আরেকজন 0 পাঠাচ্ছে, আর চুপচাপ সরে যায় (UM10204 §3.1.8). জয়ী জানেও না যে লড়াই হয়েছিল, আর তার বার্তা একটি বিটও নষ্ট হয় না। এটি একটি ধরনের bus arbitration, যেখানে ঠিকানা আর data নিজেরাই অগ্রাধিকার: ছোট মানের বার্তা জেতে। CAN bus-এর arbitration একই ধারণার ওপর দাঁড়ানো (পর্ব ৫২)।

# দুই controller একসাথে START দিল: SDA একটি wired-AND তার
def arbitrate(bytes_a, bytes_b, verbose=True):
    bits = lambda bs: [(b >> i) & 1 for b in bs for i in range(7, -1, -1)]
    a, b = bits(bytes_a), bits(bytes_b)
    alive = {"A": True, "B": True}
    for n in range(len(a)):
        sa = a[n] if alive["A"] else 1          # হেরে গেলে তার ছেড়ে দেয় (1)
        sb = b[n] if alive["B"] else 1
        sda = sa & sb                           # কেউ 0 দিলেই তারে 0
        note = ""
        for name, sent in (("A", sa), ("B", sb)):
            if alive[name] and sent == 1 and sda == 0:
                alive[name] = False
                note = f"  ← {name} 1 পাঠিয়ে 0 দেখল: হেরে গেল"
        if verbose or note:
            print(f"বিট {n + 1}: A={sa} B={sb} SDA={sda}{note}")
        if note:
            break
    return [k for k, v in alive.items() if v]

print("A: 0x48+W =", hex(0x48 << 1), " B: 0x4C+W =", hex(0x4C << 1))
print("জয়ী:", arbitrate([0x48 << 1], [0x4C << 1]))
print("একই ঠিকানা 0x90, data 0x00 বনাম 0x01:")
print("জয়ী:", arbitrate([0x90, 0x00], [0x90, 0x01], verbose=False))
print("হুবহু একই বার্তা:", arbitrate([0x90, 0x05], [0x90, 0x05], verbose=False))

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

A: 0x48+W = 0x90  B: 0x4C+W = 0x98
বিট 1: A=1 B=1 SDA=1
বিট 2: A=0 B=0 SDA=0
বিট 3: A=0 B=0 SDA=0
বিট 4: A=1 B=1 SDA=1
বিট 5: A=0 B=1 SDA=0  ← B 1 পাঠিয়ে 0 দেখল: হেরে গেল
জয়ী: ['A']
একই ঠিকানা 0x90, data 0x00 বনাম 0x01:
বিট 16: A=0 B=1 SDA=0  ← B 1 পাঠিয়ে 0 দেখল: হেরে গেল
জয়ী: ['A']
হুবহু একই বার্তা: ['A', 'B']

0x48 (1001000) আর 0x4C (1001100) প্রথম চার বিটে এক, পঞ্চম বিটে আলাদা: A দেয় 0, B দেয় 1, তার 0, B হারে। দ্বিতীয় ক্ষেত্রে ঠিকানা এক, তাই লড়াই data-তে গড়ায়, আর মেটে ১৬ নম্বর বিটে (এই মডেল ACK বিট গোনে না; ঠিকানার ACK দুজনের কাছেই একই, কারণ target-ই দেয়)। তৃতীয় ক্ষেত্রে বার্তা হুবহু এক: দুজনেই “জয়ী”, আর UM10204-ও বলে এমন হলে দুজনেই ভুল ছাড়া transaction শেষ করতে পারে। হেরে যাওয়া controller byte-এর শেষ পর্যন্ত clock দিতে পারে, তারপর bus মুক্ত হলে আবার চেষ্টা করে। নিয়মের একটি ফাঁকও আছে: একজন STOP বা repeated START দিচ্ছে আর আরেকজন তখনও data বিট, এমন অবস্থা UM10204-এ “undefined”.

SCL উঁচু থাকার মুহূর্তে
বিট
A পাঠায়
B পাঠায়
তারে SDA
অবস্থা
  1. একসাথে START. দুজনের START-এর তফাত tHD;STA-এর চেয়ে কম হলে তারে একটিই বৈধ START দেখা যায়; কেউ জানে না অন্যজনও শুরু করেছে।
  2. বিট 1. দুজনেই 1 (তার ছেড়ে দেয়), তার উঁচু। প্রত্যেকে পড়ে দেখে: যা পাঠিয়েছি তাই আছে।
  3. বিট 2–3. দুজনেই 0. Wired-AND-এ 0. এখনও কেউ কিছু টের পায় না।
  4. বিট 4. দুজনেই 1, তার 1. 0x48 আর 0x4C-এর প্রথম চার বিট 1001, একই।
  5. বিট 5, সিদ্ধান্ত। A দেয় 0, B দেয় 1 (ছেড়ে রাখে)। তার 0, কারণ A টানছে। B পড়ে 0, যা সে পাঠায়নি: হার। B সঙ্গে সঙ্গে SDA চালানো বন্ধ করে।
  6. A এগোয়। বাকি বিট 0, 0 আর W = 0; 0x48-এর sensor ACK দেয়। A-র বার্তা অক্ষত; B পরে STOP দেখে আবার চেষ্টা করবে।

আটকে যাওয়া bus আর timeout

একটি বাস্তব বিপদ: sensor যখন একটি byte পাঠাচ্ছে আর SDA-তে একটি 0 রেখেছে, ঠিক তখন MCU reset হলো। Reset-এর পরে MCU START দিতে চায়, কিন্তু SDA নিচে আটকে; sensor অপেক্ষা করছে পরের clock-এর জন্য। UM10204 §3.1.16 (“bus clear”) এর উপায় বলে: SDA আটকে থাকলে controller নয়টি clock pulse দেবে, তার মধ্যে target সাধারণত SDA ছেড়ে দেয়; না দিলে hardware reset বা power বন্ধ-চালু। SCL আটকে থাকলে hardware reset বা power cycle. অনেক firmware তাই চালু হওয়ার সময় একবার SDA দেখে নেয় আর দরকারে GPIO দিয়ে নয়টি clock দেয়। আর SMBus (I2C-এর ঘনিষ্ঠ আত্মীয়) একটি timeout রাখে: UM10204 §4.2.2 অনুযায়ী I2C-এ clock stretching-এর কোনো সময়সীমা নেই, SMBus-এ 35 ms. TMP102-ও SCL 30 ms (typ) নিচে থাকলে নিজের interface reset করে, তাই datasheet বলে SCL অন্তত 1 kHz রাখতে হবে।

আরও গভীরে: Open-drain bus-এর গতি মূলত resistor আর capacitance-এর RC দিয়ে বাঁধা, তাই দ্রুত mode-গুলো বিশেষ কৌশল নেয়। Fast-mode Plus pin-এর sink current 20 mA পর্যন্ত বাড়ায়, যাতে ছোট Rp চলে; High-speed mode-এ controller SCL-এ current-source pull-up ব্যবহার করে; আর Ultra Fast-mode পুরো push-pull, তাই সেখানে ACK বা arbitration নেই, কারণ দুজন একসঙ্গে চালাতে পারে না। একই বাধা থেকে MIPI Alliance-এর I3C এসেছে (প্রথম সংস্করণ প্রায় ২০১৬–১৭ সাল নাগাদ বলে বর্ণনা পাওয়া যায়): পুরনো I2C target-এর সঙ্গে চলতে পারে, কিন্তু নিজের data-র বেশিরভাগ push-pull-এ পাঠায় আর target-রা bus-এর ওপরেই interrupt চাইতে পারে।

পরীক্ষা ও ইন্টারভিউতে: “I2C-তে কয়টি তার, কেন open-drain?” → SDA আর SCL; বহু device একই তারে নিরাপদে চালাতে আর ACK, stretching ও arbitration-এর জন্য wired-AND. “START আর STOP কী?” → SCL উঁচু থাকতে SDA নামা আর ওঠা। “৭ বিটের ঠিকানা 0x48-এ পড়ার byte?” → 0x91. “Pull-up কীভাবে বাছবেন?” → Rp(min) = (VDD − VOL) ÷ IOL, Rp(max) = tr ÷ (0.8473 Cb). “পড়ার শেষ byte-এ controller কী দেয়?” → NACK, তারপর STOP.

৮ · AI-এর যুগে I2C-এর কোড আর হিসাব যাচাই

AI assistant-এর কাছে STM32-এ TMP102 পড়ার কোড চাইলে সাধারণত চলনসই দেখতে কোড আসে। কিন্তু I2C-এর ভুলগুলো কম্পাইলে ধরা পড়ে না; ধরা পড়ে bus-এ, আর প্রায়ই শুধু কিছু তাপমাত্রায়। পরিচিত ভুল আর ধরার উপায়:

AI প্রায়ই যা করেকীভাবে ধরবেন
৭ বিটের ঠিকানা আর ৮ বিটের রূপ মিশিয়ে ফেলে (0x48 বনাম 0x90)Library-র documentation দেখা, আর প্রথম run-এ ঠিকানার NACK পরীক্ষা করা
Raw মান sign extension ছাড়া shift করে, বা ১২ বিটকে ১৬ বিট ধরে 0.0625-এ গুণ করে−0.50 °C (0xFF80) আর −25 °C (0xE700) দিয়ে host-এ পরীক্ষা
NACK দেখে না, বা অপেক্ষার loop-এ timeout রাখে নাভুল ঠিকানায় চালিয়ে দেখা firmware কী করে; প্রতিটি অপেক্ষায় সীমা
“সব জায়গায় 4.7 kΩ” বা “10 kΩ” pull-up বলে দেয়, হিসাব ছাড়াRp(min) আর Rp(max) নিজে হিসাব, module-এর নিজের pull-up যোগ করে
Chip-এর register-এর ঠিকানা, reset মান বা গতির সীমা বানিয়ে বলেDatasheet-এর register map (যেমন TMP102-এর pointer 0x00–0x03, config 0x60A0)
ISR-এর ভেতরে blocking I2C read বা printf রাখেISR-এ শুধু flag; পড়া main loop বা task-এ, বা interrupt-চালিত driver (পর্ব ৪৩)

প্রসঙ্গ আর যাচাইয়ের শর্ত শুরুতেই দিন:

আমি একটি Cortex-M3 microcontroller-এ bare-metal C-তে একটি TMP102 তাপমাত্রার sensor পড়তে চাই, I2C 100 kHz, ঠিকানা ADD0 ground-এ, 3.3 V. ১. প্রথমে বলো sensor-এর ৭ বিটের ঠিকানা কত, আর লেখা ও পড়ার byte কত। Datasheet-এর কোন টেবিল থেকে নিলে, তাও বলো। ২. Pointer register লিখে repeated START দিয়ে দুই byte পড়ার ধাপগুলো বিট ধরে লিখে দাও: কোথায় ACK, কোথায় NACK. ৩. Raw মান থেকে °C বের করো float ছাড়া, sign extension সহ; −0.50 °C আর −25 °C-এর raw মান দিয়ে নিজের কোড যাচাই করে দেখাও। ৪. NACK আর bus আটকে যাওয়ার জন্য timeout রাখো; তিনবার পরপর ব্যর্থ হলে একটি sensor fault জানাও। ৫. 30 cm তার আর তিনটি chip-এর জন্য pull-up resistor হিসাব করে দেখাও, UM10204-এর সূত্রে। কোনো সংখ্যা নিশ্চিত না হলে স্পষ্ট বলো।

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

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

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

প্র ০১১৯৮২ সালে Philips একটি দুই তারের bus বানাল। কোন সমস্যার সমাধানে, আর চার দশক পরেও এটি এত ছড়িয়ে আছে কেন?

UM10204-এর revision তালিকা I2C-এর প্রথম সংস্করণকে ১৯৮২ সালের বলে দেখায়। প্রচলিত বর্ণনা অনুযায়ী Philips-এর লক্ষ্য ছিল টেলিভিশন আর অডিও যন্ত্রের ভেতরে কয়েকটি chip, যেমন tuner, অডিও প্রসেসর আর একটি নিয়ন্ত্রক microcontroller, কম তারে জোড়া। একটি TV-র board-এ প্রতিটি chip-এর জন্য আলাদা data আর select তার মানে বেশি pin, বড় PCB আর বেশি খরচ। দুটি তার, আর প্রতিটি chip-এর নিজস্ব ঠিকানা: নতুন chip যোগ করতে শুধু দুটি তারে জোড়া। গতি দরকার ছিল কম, কারণ ভলিউম বা চ্যানেল বদলানোর আদেশ কয়েকটি byte মাত্র; তাই 100 kbit/s তখন যথেষ্ট ছিল।

এরপরের ইতিহাসও revision তালিকায় আছে: ১৯৯২ সালের version 1.0, ১৯৯৮ সালের version 2.0 (যার সূচনায় বলা হয়েছে bus তখন হাজারের বেশি আলাদা IC-তে), ২০০৭ সালের revision-এ Fast-mode Plus, পরের সংস্করণগুলোতে Ultra Fast-mode, আর ২০২১ সালে controller/target শব্দ। প্রতিটি ধাপে পুরনো chip-এর সঙ্গে চলার ক্ষমতা রাখা হয়েছে: একটি Fast-mode controller Standard-mode target-এর সঙ্গে 100 kHz-এ কথা বলতে পারে। এই পেছনের দিকের মিল একটি বড় কারণ যে আজও নতুন sensor I2C দিয়ে বের হয়।

আরেকটি কারণ নকশার সরলতা। Clock controller দেয়, তাই target-এর কোনো crystal লাগে না; UART-এর মতো দুই পক্ষের baud rate মেলাতে হয় না। ACK থাকায় controller জানে কেউ শুনল কি না, যা UART-এ নেই। আর একই দুই তারে ঠিকানা দিয়ে এক ডজন chip ঝোলানো যায়। এর দাম গতি আর দূরত্ব: open-drain-এর RC rise time আর 400 pF-এর মতো capacitance-এর সীমা I2C-কে একটি board-এর ভেতরে বা খুব কাছের module-এ বেঁধে রাখে। বাজারঘরের cold room-এ sensor যদি ঘরের ভেতরে কয়েক মিটার দূরে বসাতে হয়, তবে সরাসরি I2C তার না টেনে sensor-এর কাছে একটি ছোট MCU আর RS-485 (পর্ব ৫৩) বা একটি I2C buffer বিবেচনা করা ভালো।

মূল উপলব্ধি: I2C জন্মেছিল একটি board-এর ভেতরে কম তারে অনেক ধীর chip জোড়ার জন্য; ঠিকানা, ACK আর controller-এর clock তাকে সরল রেখেছে, আর পেছনের দিকের মিল তাকে টিকিয়ে রেখেছে, তবে দূরত্ব আর গতিতে তার সীমা RC.

প্র ০২বাজারঘরের cold room-এর জন্য I2C, SPI আর UART-এর মধ্যে sensor বাছাই করতে হলে কোন প্রশ্নগুলো করবেন?

প্রথম প্রশ্ন data-র পরিমাণ আর গতি। Cold room-এর sensor প্রতি সেকেন্ডে দুই byte দেয় (README: প্রতি 1 s-এ একটি পড়া)। এই পর্বের হিসাবে একটি পড়া 100 kHz-এ প্রায় 450 µs, অর্থাৎ bus প্রায় সবসময় খালি। এখানে গতি কোনো বাধা নয়। কিন্তু একটি display-তে ছবি পাঠানো বা একটি flash chip থেকে firmware পড়ার মতো কাজে প্রতি সেকেন্ডে লাখ লাখ byte; সেখানে SPI-এর কয়েক MHz-এর push-pull clock (পর্ব ৫০) I2C-এর চেয়ে অনেক ভালো, কারণ SPI-এর গতি RC rise time-এ বাঁধা নয়।

দ্বিতীয় প্রশ্ন pin আর device-এর সংখ্যা। I2C-তে device যত বাড়ুক, তার দুটিই; SPI-তে প্রতিটি নতুন device-এর জন্য একটি chip select pin. বাজারঘরের board-এ যদি তাপমাত্রা, আর্দ্রতা, দরজার একটি sensor আর একটি RTC থাকে, I2C স্বাভাবিক পছন্দ, যতক্ষণ ঠিকানাগুলো আলাদা। ঠিকানা মিলে গেলে (যেমন একই sensor-এর পাঁচটি, অথচ ADD0 দিয়ে মাত্র চারটি ঠিকানা) একটি I2C multiplexer বা দ্বিতীয় bus লাগে।

তৃতীয় প্রশ্ন দূরত্ব আর বিশ্বাসযোগ্যতা। I2C আর SPI দুটিই board-এর ভেতরের bus; UART-এর TTL স্তরও খুব দূরে যায় না, কিন্তু UART-কে RS-232 বা RS-485-এ নিলে মিটার থেকে শত মিটার যাওয়া যায় (পর্ব ৪৯ আর ৫৩)। I2C-এর একটি বিশেষ সুবিধা ACK: device হারালে firmware সঙ্গে সঙ্গে জানে, যা এই পর্বের SENSOR FAULT-এর ভিত্তি। SPI-তে বিচ্ছিন্ন device-এর MISO প্রায়ই সব 1 বা সব 0 দেয়, যা দেখতে বৈধ data-র মতো, তাই সেখানে firmware-কে একটি ID register পড়ে বা CRC দেখে নিশ্চিত হতে হয়। চতুর্থ প্রশ্ন বিদ্যুৎ: I2C-এর pull-up LOW-এর সময় current টানে (2.2 kΩ-এ 1.32 mA প্রতি তার), যা battery-চালিত যন্ত্রে পর্ব ৬২-এর হিসাবে গুনতে হয়।

শেষে বাজার নিজেই একটি উত্তর দেয়: যে sensor আপনি চান তা কোন interface-এ পাওয়া যায়। TMP102 শুধু I2C/SMBus-ধাঁচের two-wire interface দেয়, তাই এখানে সিদ্ধান্ত সহজ। নকশার ভালো অভ্যাস হলো driver এমনভাবে লেখা যাতে “দুই byte পড়া” কাজটি একটি ছোট function-এর আড়ালে থাকে; পরে sensor বদলালে বাকি firmware (alarm, hysteresis, telemetry) অক্ষত থাকে।

মূল উপলব্ধি: গতি আর data-র পরিমাণ, pin আর device-এর সংখ্যা, দূরত্ব, ব্যর্থতা ধরার ক্ষমতা আর বিদ্যুৎ: এই পাঁচ প্রশ্নে interface বাছুন; ধীর, কাছের, অনেক sensor-এ I2C প্রায়ই সেরা।

প্র ০৩Clock stretching কেন বিতর্কিত? কোন ধরনের controller এতে বিপদে পড়ে, আর SMBus কেন সময়সীমা বসাল?

Clock stretching-এর ধারণা সুন্দর: ধীর target controller-কে কোনো আলাদা তার ছাড়াই থামাতে পারে, শুধু SCL নিচে ধরে রেখে। UM10204 দুই স্তরের কথা বলে: byte-এর স্তরে (একটি byte নেওয়ার পরে ভেতরে রাখার সময় চাওয়া) আর বিটের স্তরে (একটি ধীর microcontroller-এর প্রতিটি clock-এর নিচু অংশ লম্বা করা)। একটি target যদি নিজেই একটি microcontroller হয়, যে software দিয়ে I2C-এর জবাব বানায়, তার জন্য এটি প্রায় অপরিহার্য।

বিপদ আসে controller-এর দিক থেকে। Controller-এর hardware বা bit-bang code-কে SCL ছেড়ে দেওয়ার পরে তার আসলে উঁচু হলো কি না পড়ে দেখতে হয়, আর না হলে অপেক্ষা করতে হয়। কিছু controller-এর hardware বা driver এটি পুরোপুরি মানে না, বা খুব ছোট stretching-এ ভুল করে; বিভিন্ন জনপ্রিয় board-এর I2C-তে stretching নিয়ে সমস্যার কথা বহু ব্যবহারকারী জানিয়েছেন, তাই আপনার chip-এর errata আর driver-এর বর্ণনা দেখে নিন। ফল হয় ভুল বিট, অদ্ভুত NACK, বা মাঝে মাঝে আটকে যাওয়া, যা ধরা খুব কঠিন কারণ সমস্যা শুধু target ব্যস্ত থাকলেই দেখা দেয়।

দ্বিতীয় বিপদ সময়ের সীমা না থাকা। UM10204 §4.2.2 স্পষ্ট বলে: I2C-এ stretching কতক্ষণ চলতে পারে তার কোনো সীমা নেই; I2C একটি “DC bus”, clock শূন্যে নেমে থাকতে পারে। একটি target ভুল করে SCL চিরকাল নিচে ধরে রাখলে পুরো bus মৃত। SMBus, যা I2C-এর ওপর ভিত্তি করে কম্পিউটারের ভেতরের ব্যাটারি, তাপমাত্রা আর power-এর ছোট chip-এর জন্য তৈরি, তাই একটি timeout বসাল: UM10204-এর বর্ণনায় 35 ms; এর বেশি হলে সব device ধরে নেয় bus-এ সমস্যা আর নিজেদের interface reset করে। এজন্য SMBus-এর সর্বনিম্ন clock 10 kHz. TMP102-এর নিজের 30 ms (typ) timeout আর “SCL অন্তত 1 kHz” নিয়ম এই চিন্তারই অংশ।

Firmware-এর জন্য শিক্ষা তিনটি। এক, controller-এর প্রতিটি অপেক্ষায় সময়সীমা রাখুন (এই পর্বের i2c_read16()-এর মতো), তারপর পুনরুদ্ধারের পথ: bus clear-এর নয়টি clock, peripheral reset, তারপর আবার চেষ্টা। দুই, target বাছাইয়ের সময় datasheet-এ দেখুন সে stretching করে কি না আর কতক্ষণ। তিন, পরীক্ষায় শুধু খুশির পথ নয়, ধীর target-এর পথও চালান।

মূল উপলব্ধি: Clock stretching ধীর target-কে বাঁচায় কিন্তু controller-কে সতর্ক হতে বাধ্য করে; সীমাহীন অপেক্ষা I2C-এর একটি দুর্বলতা, যা SMBus-এর timeout আর firmware-এর নিজের সময়সীমা দিয়ে ঢাকতে হয়।

প্র ০৪MCU reset হলো আর I2C bus-এর SDA নিচে আটকে গেল। কেন এমন হয়, আর firmware নিরাপদে কীভাবে ফিরবে?

I2C-এর target-এর কোনো নিজস্ব সময়ের ধারণা নেই; সে চলে controller-এর clock-এ। ধরুন sensor 0x04 পাঠাচ্ছে (00000100), তৃতীয় বিট পর্যন্ত এসেছে, আর SDA-তে একটি 0 রেখেছে। ঠিক তখন MCU-র watchdog reset হলো (পর্ব ৬১)। MCU-র I2C peripheral reset হয়, কিন্তু sensor-এর power চলে যায়নি, তাই সে এখনও ভাবছে “পরের clock এলে পরের বিট দেব”, আর ততক্ষণ SDA নিচে ধরে রাখছে। Reset-এর পরে MCU START দিতে চায়: START মানে SCL উঁচু থাকতে SDA নামানো, কিন্তু SDA আগে থেকেই নিচে। MCU-র hardware “bus busy” বা arbitration হারানো দেখায়, আর firmware যদি সময়সীমা ছাড়া অপেক্ষা করে, যন্ত্র আবার আটকে যায়, আবার watchdog, আবার একই অবস্থা।

UM10204 §3.1.16 সমাধান দেয়: SDA আটকে থাকলে controller নয়টি clock pulse দেবে। কেন নয়? Target যে byte-এর মাঝখানে আছে, তার বাকি বিট আর ACK মিলিয়ে সর্বোচ্চ নয়টি clock; প্রতিটি clock-এ target একটি বিট শেষ করে, আর কোনো এক সময়ে একটি 1 বিট বা ACK-এর জায়গায় SDA ছেড়ে দেয়। Controller-এর NACK-এর মতো আচরণে (SDA উঁচু রাখা) target বোঝে পড়া শেষ। তারপর controller একটি STOP দেয়, আর bus আবার পরিষ্কার। নয় clock-এর পরেও না ছাড়লে hardware reset pin বা device-এর power বন্ধ-চালু।

বাস্তবে firmware-এ এটি সাধারণত চালু হওয়ার কোডে থাকে: I2C peripheral চালুর আগে SDA আর SCL pin GPIO হিসেবে পড়া; SDA নিচে হলে SCL-কে open-drain GPIO করে হাতে নয়টি pulse দেওয়া (পর্ব ৪১-এর open-drain output), তারপর STOP, তারপর peripheral-এর হাতে pin ফেরত। কিছু MCU-র I2C peripheral নিজেই এমন bus-recovery-র সুবিধা দেয়; reference manual দেখুন। আর নকশার স্তরে একটি সহজ কৌশল: sensor-এর power একটি GPIO বা load switch দিয়ে নিয়ন্ত্রণ করা, যাতে শেষ উপায় হিসেবে firmware নিজেই power cycle করতে পারে।

কোর্সের board এই অবস্থা দেখাতে পারে না (Spec decision 26: কোনো বিট-সময় বা bus অবস্থা মডেল নেই), তাই এখানে কথাটি UM10204 থেকে। কিন্তু নীতিটি এই পর্বের run-এই দেখা: অপেক্ষায় সময়সীমা, ব্যর্থতা গোনা, আর তিনবারের পরে fault জানানো, যাতে একটি আটকে যাওয়া bus কখনো চুপচাপ cold room-কে অরক্ষিত না রাখে।

মূল উপলব্ধি: I2C-এর target controller-এর clock ছাড়া এগোয় না, তাই মাঝপথে reset হলে SDA আটকে যেতে পারে; নয়টি clock, STOP, তারপর দরকারে reset বা power cycle, আর সব অপেক্ষায় সময়সীমা।

প্র ০৫একটি নিরাপত্তা-সংবেদনশীল device-এ (যেমন ওষুধ বা খাবারের cold room) I2C sensor-এর পড়াকে কতটা বিশ্বাস করবেন? কোন কোন পরীক্ষা যোগ করবেন?

এই পর্বের run দুটি ফাঁদ দেখিয়েছে। এক, NACK এড়িয়ে গেলে alarm কখনো বাজে না: sensor হারিয়ে গেলে তাপমাত্রা উঠলেও firmware নীরব। দুই, NACK না দেখে DATA পড়লে 0xFFFF থেকে −0.0625 °C আসে, একটি সম্পূর্ণ বিশ্বাসযোগ্য মান। দ্বিতীয়টি আরও ভয়ংকর, কারণ dashboard-এ সব ঠিক দেখাবে। তাই প্রথম স্তরের পরীক্ষা protocol-এর: প্রতিটি পড়ায় ACK আর DONE দেখা, অপেক্ষায় timeout, আর পরপর ব্যর্থতার একটি সীমা পেরোলে fault alarm, যা এই পর্বের coldroom_fault.c করেছে।

দ্বিতীয় স্তর মানের যুক্তি (plausibility). TMP102-এর পরিসর −40 থেকে 125 °C (datasheet), আর একটি cold room-এ মান সাধারণত 0 থেকে 8 °C-এর কাছে। এক সেকেন্ডে 4 °C থেকে 40 °C-এ লাফ শারীরিকভাবে প্রায় অসম্ভব; এমন লাফ একটি bus-এর ভুল, একটি ঢিলা সংযোগ বা noise-এর লক্ষণ। Firmware পরিবর্তনের হারের একটি সীমা রাখতে পারে, আর সন্দেহজনক মান alarm-এর গোনায় না ধরে আলাদা “সন্দেহ” হিসেবে গুনতে পারে। আরেকটি সহজ পরীক্ষা: sensor-এর configuration register (power-up মান 0x60A0) মাঝে মাঝে পড়ে দেখা, যা অনেকটা chip-এর পরিচয় যাচাই; মান না মিললে ঠিকানায় অন্য কিছু বসে আছে বা chip reset হয়েছে।

তৃতীয় স্তর redundancy. খুব জরুরি জায়গায় দুটি sensor, আলাদা ঠিকানায় (0x48 আর 0x49), আর দুজনের মানের পার্থক্য একটি সীমা ছাড়ালে সতর্কতা। একই bus-এ দুটি রাখলে একটি bus-এর আটকে যাওয়া দুটিকেই অচল করে, তাই আরও কঠোর নকশায় আলাদা bus বা আলাদা ধরনের sensor (যেমন একটি thermistor আর ADC, পর্ব ৪৭)। Accuracy-ও মনে রাখুন: TMP102-এর datasheet-এ −25 থেকে 85 °C-এ ত্রুটির typical মান ±0.5 °C আর সর্বোচ্চ ±2 °C. 8.00 °C-এর সীমার কাছে 2 °C পর্যন্ত ভুল সম্ভব হলে নিরাপদ নকশা সীমাটি একটু ভেতরে টানে, বা calibration করে (পর্ব ৬৬)।

শেষ স্তর ব্যবস্থার: alarm-এর output নিজেই কাজ করছে কি না, firmware আটকে গেলে watchdog, আর cloud-এ telemetry না এলে (README: প্রতি 10 s) dashboard-এ “device নীরব” সতর্কতা, যা MQTT-এর Last Will দিয়ে সহজ হয় (পর্ব ৭৩)। প্রতিটি স্তর আলাদা ধরনের ব্যর্থতা ধরে; একসাথে তারা একটি চুপচাপ ব্যর্থতার সম্ভাবনা অনেক কমায়।

মূল উপলব্ধি: I2C-এর একটি পড়া তখনই বিশ্বাসযোগ্য যখন protocol (ACK, timeout), মান (পরিসর, হার), chip-এর পরিচয় আর ব্যবস্থা (watchdog, telemetry) সব স্তরে পরীক্ষা পাস করে; “মাপতে না পারা” নিজেই একটি alarm.

অনুশীলন

প্রথমে নিজে লিখুন বা হিসাব করুন, তারপর উত্তর খুলুন। প্রতিটি উত্তর Python-এ বা কোর্সের virtual board-এ চালিয়ে যাচাই করা।

  1. নকশা ও বাস্তবায়ন — sensor fault: বাজারঘর board-এর cold-room firmware-এ tsens_read() NACK পেলে −1 দেয়, আর main loop শুধু “sensor NACK” ছেপে পরের সেকেন্ডে যায়। এমন পরিবর্তন লিখুন যাতে পরপর ৩টি NACK হলে PA6-এর alarm চালু হয় আর UART-এ ALARM ON: SENSOR FAULT আসে, আর একটি সফল পড়া গোনা শূন্য করে। ঠিকানা ভুল করে 0x49 দিলে কখন alarm বাজবে?
    uint32_t nack_count = 0;            /* main-এর অন্য গোনার পাশে */
    ...
    if (tsens_read(&t16) != 0) {
        uart_puts("sensor NACK\r\n");
        if (++nack_count == CONFIRM) {  /* 3 misses in a row */
            GPIOA->BSRR = 1u << ALARM_PIN;
            uart_puts("ALARM ON: SENSOR FAULT\r\n");
        }
        continue;
    }
    nack_count = 0;

    এটিই আমার lab-এর coldroom_fault.c. ঠিকানা 0x49-এ প্রতি সেকেন্ডে একটি NACK: 1 s, 2 s, আর 3 s-এ তৃতীয়টি। Board-এর run-এ [ 3000.0199 ms] GPIO PA6 ALARM ON আর তারপর ALARM ON: SENSOR FAULT. == CONFIRM (>= নয়) রাখায় বার্তা একবারই ছাপে। একটি ভালো সংযোজন হবে sensor ফিরলে fault-এর alarm বন্ধ করার নিয়ম, যাতে HIGH/LOW alarm-এর সঙ্গে না মেশে; সেজন্য enum alarm-এ একটি নতুন অবস্থা (যেমন ALARM_FAULT) রাখা পরিষ্কার পথ।

  2. ভুল খুঁজুন — দুটি ভুল এক function-এ: একজন datasheet-এ “address byte 0x90” দেখে লিখেছেন:
    static int read_bad(int32_t *t16)
    {
        I2C1->ADDR = 0x90u;
        I2C1->REG = TSENS_REG_TEMP;
        I2C1->CR = I2C_CR_START;
        while ((I2C1->SR & (I2C_SR_DONE | I2C_SR_NACK)) == 0) { }
        if (I2C1->SR & I2C_SR_NACK) return -1;
        *t16 = I2C1->DATA >> 4;
        return 0;
    }
    প্রথমে sensor সাড়াই দেয় না। ঠিকানা ঠিক করার পরে ঘর −0.50 °C হলে alarm-এর হিসাবে কী ঘটে? দুটি ভুল আর ঠিক রূপ লিখুন।

    ভুল ১: 0x90 হলো ঠিকানা + W-এর byte, ৭ বিটের ঠিকানা নয়। Board-এর ADDR register ৭ বিট রাখে (0x90 & 0x7F = 0x10), তাই 0x10-কে ডাকা হয়, আর NACK. ঠিক: I2C1->ADDR = 0x48u; (বা TSENS_ADDR). ভুল ২: DATA >> 4 unsigned shift, তাই 0xFF80 থেকে 4088, অর্থাৎ 255.5 °C. 4088 > 128, তাই HIGH-এর গোনা বাড়ে: ঠান্ডা ঘরে “গরম” alarm. ঠিক: *t16 = (int32_t)(int16_t)I2C1->DATA >> 4;. আমার lab-এর bad.c board-এ চালিয়ে দেখা ফল:

    [     0.0143 ms] UART: 0x90: NACK
    [     0.0614 ms] UART: no sign ext: t16=4088 -> HIGH alarm count!
    [     0.0991 ms] UART: fixed:       t16=-8 T=-0.50 C

    একটি তৃতীয় দুর্বলতাও আছে: অপেক্ষার loop-এ timeout নেই। এই board-এ উত্তর সবসময় আসে, কিন্তু আসল bus আটকে গেলে function কখনো ফেরে না।

  3. হিসাব — 5 V-এর bus-এ pull-up: একটি পুরনো 5 V-এর board, আনুমানিক Cb = 200 pF, VOL = 0.4 V at 3 mA. (ক) Standard-mode-এ Rp-এর জানালা কত, আর 4.7 kΩ নিলে rise time আর LOW-এর current কত? (খ) একই bus Fast-mode-এ চালাতে চাইলে জানালা কত, আর কোন প্রচলিত মান চলবে?

    (ক) Rp(min) = (5 − 0.4) V ÷ 3 mA = 1533 Ω. Rp(max) = 1000 ns ÷ (0.8473 × 200 pF) = 5901 Ω. 4.7 kΩ জানালার ভেতরে: tr = 0.8473 × 4.7 kΩ × 200 pF = 796 ns (1000 ns-এর নিচে), LOW-এ 4.6 V ÷ 4.7 kΩ = 0.98 mA. (খ) Rp(max) = 300 ns ÷ (0.8473 × 200 pF) = 1770 Ω, তাই জানালা মাত্র 1533 থেকে 1770 Ω. E12-এর 1.5 kΩ খুব ছোট, 1.8 kΩ খুব বড়; E24-এর 1.6 kΩ চলে: tr = 271 ns, current 2.88 mA, 3 mA-এর খুব কাছে। এত সরু জানালা একটি সতর্ক সংকেত: capacitance কমানো (ছোট তার, কম device) বা bus ভাগ করা ভালো। সব সংখ্যা Python-এ মেলানো।

  4. আগে বলুন — আরেকটি sensor: একটি TMP102-এর ADD0 pin SDA-তে জোড়া। (ক) তার ৭ বিটের ঠিকানা, লেখা ও পড়ার byte কত? (খ) Configuration register (pointer 0x01) পড়তে পুরো transaction কয়টি SCL clock নেবে, আর আসল chip power-up-এর পরে কোন দুই byte দেবে? (গ) Temperature register থেকে 0xFE 0x70 এলে t16, °C, firmware-এর ছাপা মান (t16 * 25 / 4) আর cold-room alarm-এর হিসাব কী?

    (ক) Datasheet-এর Table 6-4: SDA-তে 1001010 = 0x4A; লেখা 0x94, পড়া 0x95. (খ) একই ধাঁচ: ঠিকানা + W, pointer 0x01, Sr, ঠিকানা + R, দুই byte: ৫ byte × ৯ = ৪৫ clock. আসল TMP102 power-up-এ দেয় 0x60 আর 0xA0 (Table 6-10, 6-11). কোর্সের board-এর sensor শুধু register 0x00 জানে, তাই সেখানে 0x0000 আসে (এই পর্বের run-এর শেষ লাইন)। (গ) 0xFE70 >> 4 = 0xFE7 = 4071, বিট 11 = 1, তাই 4071 − 4096 = −25. °C = −25 × 0.0625 = −1.5625. ছাপা: −625 ÷ 4 = −156.25 → C-ভাগে −156, অর্থাৎ “-1.56”. −25 < 0, তাই LOW-এর গোনা বাড়ে; পরপর তিনটি এমন পড়ায় ALARM ON: LOW temperature. সব মান Python-এ চালিয়ে মেলানো।

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

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

ক্রমএকটি controller TMP102-ধাঁচের sensor-এর temperature register (pointer 0x00) পড়বে। Bus-এ ঘটনাগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. START, তারপর ঠিকানা + W (0x90) আর sensor-এর ACK
  2. Pointer byte 0x00 আর sensor-এর ACK
  3. Repeated START, তারপর ঠিকানা + R (0x91) আর sensor-এর ACK
  4. Sensor পাঠায় MSB, controller দেয় ACK
  5. Sensor পাঠায় LSB, controller দেয় NACK
  6. STOP, আর দুই byte থেকে sign extension করে °C

I2C bus-এ START condition কোনটি?

  • SCL নিচু থাকা অবস্থায় SDA 1 থেকে 0-তে নামা
  • SCL উঁচু থাকা অবস্থায় SDA 0 থেকে 1-এ ওঠা
  • SCL উঁচু থাকা অবস্থায় SDA 1 থেকে 0-তে নামা
  • প্রথম SCL pulse-এ SDA 0 থাকা

একটি I2C sensor-এর ৭ বিটের ঠিকানা 0x48. পড়ার (R/W = 1) জন্য START-এর পরে প্রথম byte কোনটি?

  • 0x48
  • 0x91
  • 0x90
  • 0x49

VDD = 3.3 V, Fast-mode (tr ≤ 300 ns, IOL = 3 mA at VOL = 0.4 V), Cb = 100 pF. UM10204-এর সূত্রে কোন pull-up জানালার ভেতরে?

  • 10 kΩ
  • 470 Ω
  • 4.7 kΩ
  • 2.2 kΩ

একটি controller sensor থেকে দুই byte পড়ছে। দ্বিতীয় (শেষ) byte পাওয়ার পরে ৯ নম্বর clock-এ controller কী করে, আর কেন?

  • NACK দেয় (SDA ছেড়ে রাখে), যাতে target আর byte না পাঠায়
  • ACK দেয়, কারণ byte ঠিকমতো এসেছে
  • কিছুই করে না; ৯ নম্বর clock শুধু লেখার সময় থাকে
  • ৯ নম্বর clock-এর বদলে সরাসরি repeated START দেয়

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

  • 255.5 °C
  • 4088 °C
  • −0.50 °C
  • −0.0625 °C

দুই I2C controller একসাথে START দিল: A ডাকে ৭ বিটের 0x48, B ডাকে 0x4C, দুজনেই লেখার জন্য। কী ঘটবে?

  • B জিতবে, কারণ তার ঠিকানা বড়
  • পঞ্চম বিটে B হারবে আর সরে যাবে; A-র transaction অক্ষত থাকবে
  • তারে short circuit হবে আর দুটি transaction নষ্ট হবে
  • 0x48-এর sensor ঠিক করবে কে জিতবে

একটি cold-room firmware sensor-কে I2C-তে পড়ে; ঠিকানা ভুল হলে hardware NACK জানায় আর data register-এ 0xFFFF থাকে। কোন আচরণটি সবচেয়ে নিরাপদ?

  • NACK না দেখে data register পড়ে তাপমাত্রা হিসাব করা
  • Sensor সাড়া না দেওয়া পর্যন্ত সময়সীমা ছাড়া অপেক্ষা করা
  • “sensor NACK” ছেপে চুপচাপ পরের পড়ায় যাওয়া, অনির্দিষ্টকাল
  • Timeout রেখে NACK-এ data বাদ দেওয়া, আর পরপর তিনটি ব্যর্থতায় sensor-fault alarm চালু করা

শব্দকোষ

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

মনে রাখুন

  1. দুই তার, wired-AND: SDA আর SCL open-drain, pull-up দিয়ে উঁচু; কেউ টানলেই 0. ACK, clock stretching আর arbitration এই নিয়ম থেকেই।
  2. Pull-up-এর জানালা: (VDD − VOL) ÷ IOL ≤ Rp ≤ tr ÷ (0.8473 Cb); capacitance বাড়লে জানালা সরু হয়, বন্ধও হতে পারে।
  3. Frame: START ও STOP SCL উঁচু থাকতে SDA-র বদল; byte MSB আগে, প্রতিটির পরে ACK/NACK; ঠিকানা ৭ বিট + R/W (0x48 → 0x90/0x91).
  4. Register read: ঠিকানা + W, pointer, repeated START, ঠিকানা + R, দুই byte (শেষটিতে NACK), STOP; ৪৫ clock. Raw → °C: (int16_t)raw >> 4, তারপর ÷ 16.
  5. ব্যর্থতা সামলানো: NACK-এ data বাদ, প্রতিটি অপেক্ষায় timeout, পরপর তিনবারে sensor fault; আটকে যাওয়া SDA-তে নয়টি clock আর STOP.

পরের পর্বে: পর্ব ৫২ (CAN bus — frame, arbitration আর গাড়ির network). এখানে দেখা wired-AND-এর arbitration-ই সেখানে dominant আর recessive বিট হয়ে আসে, differential তারে, frame, bit stuffing আর CRC নিয়ে।

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

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