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

SPI — clock polarity, phase, chip select আর full duplex

SPI — Clock Polarity, Phase, Chip Select and Full Duplex

Taught in Bangla, this lesson explains SPI's four wires and how two 8-bit shift registers swap bytes in full duplex, so reads need dummy bytes. In-page Python shows all four CPOL/CPHA modes and what a mismatch does to 0x9F, daisy-chained devices, and a W25Q128JV-style flash model answering JEDEC ID EF 40 18 with read, program and status commands. STM32F103 SPI register setup is shown as example code, and a bit-banged SPI master runs on the course's virtual BG-M3 board with its pin edges analysed.

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

  • SPI-এর চারটি সংকেত, master আর slave-এর ভূমিকা, আর কেন একে full duplex বলা হয়
  • CPOL আর CPHA দিয়ে চারটি mode, timing diagram পড়া, আর mode না মিললে কী ঘটে তা মডেলে দেখা
  • কয়েকটি slave: আলাদা chip select বনাম daisy chain, আর দুটি CS একসাথে নামলে কী বিপদ
  • একটি আসল SPI flash-এর command (9Fh, 06h, 02h, 20h, 05h, 03h) দিয়ে বাজারঘরের cold room-এর log লেখা আর পড়া
  • STM32F103-এর SPI register সাজানো, আর virtual board-এ GPIO দিয়ে SPI চালিয়ে প্রতিটি ধার cycle ধরে মাপা

১ · SPI কী — চার তার, এক master আর কয়েকটি slave

বাজারঘরের cold-storage monitor প্রতি ১০ সেকেন্ডে একটি তাপমাত্রার হিসাব MQTT-তে পাঠায়। কিন্তু Wi-Fi চলে গেলে? দোকানের মালিক পরে জানতে চাইবেন, রাত দুটোয় ঘর কত গরম হয়েছিল। তাই নকশায় একটি ছোট বাইরের flash memory chip যোগ করা হলো, যেখানে প্রতিটি হিসাব জমা থাকবে। Microcontroller আর এই chip-এর মধ্যে কথা হয় SPI (Serial Peripheral Interface) দিয়ে। SD card, অনেক ছোট display, ADC, DAC আর shift register chip-ও এই একই ভাষায় কথা বলে।

SPI-তে চারটি তার। SCK (কোথাও SCLK লেখা) হলো clock, যা সবসময় master, অর্থাৎ microcontroller চালায়। MOSI (master out, slave in) তারে master থেকে বিট যায়। MISO (master in, slave out) তারে বিট ফেরে। আর chip select (CS, কোথাও SS বা NSS) একটি আলাদা তার, যা সাধারণত active low: master কোনো slave-এর CS নামিয়ে 0 করলে সেই slave জাগে, বাকিরা চুপ থাকে। নামগুলো নিয়ে একটি কথা: কিছু নতুন নথিতে “master/slave”-এর বদলে “controller/peripheral”, আর তারের নাম COPI/CIPO বা SDO/SDI লেখা হয়; chip-এর datasheet যে নাম ব্যবহার করে, সেটিই মিলিয়ে পড়ুন।

UART-এর সঙ্গে মূল পার্থক্য clock-এ। UART-এ দুই প্রান্ত আলাদা ঘড়ি ধরে বিট গোনে, তাই baud rate দুই দিকে মিলতে হয় (পর্ব ৪৯, UART). SPI-তে প্রতিটি বিটের সঙ্গে master নিজেই একটি clock pulse পাঠায়; slave শুধু সেই ধার দেখে বিট পড়ে। এ কারণে SPI-কে synchronous serial বলা হয়, আর এর গতি কয়েক kHz থেকে কয়েক দশ MHz পর্যন্ত যেকোনো কিছু হতে পারে, এমনকি অসমান ছন্দেও (অংশ ৭-এর আসল run তার প্রমাণ)। দাম হলো তার বেশি লাগে, আর প্রতিটি slave-এর জন্য সাধারণত একটি করে CS. পরের পর্বের I2C (পর্ব ৫১) দুটি তারে ঠিকানা দিয়ে অনেক যন্ত্র চালায়, কিন্তু ধীরে।

উপমা — দুই দোকানির খাতা বদল: দুই পাশাপাশি দোকানি একটি টেবিলের দুই পাশে বসে আছেন, প্রত্যেকের হাতে আটটি কার্ডের একটি সারি। মালিক (master) হাততালি দিলেই দুজনে নিজের সারির প্রথম কার্ডটি একসাথে অন্যজনের দিকে ঠেলে দেন আর অন্যজনের কার্ড নিজের সারির শেষে বসান। আটটি হাততালির পরে দুজনের সারি পুরো বদলে গেছে। হাততালির ছন্দ ধীর হোক বা দ্রুত, কিছু যায় আসে না; শুধু হাততালি শোনা চাই। আর মালিক যার দিকে আঙুল তোলেন (CS), শুধু সেই দোকানি খেলায় যোগ দেন।

লেখার নিয়ম আর lab: এই পর্বে hex লেখা হয় C-র ধাঁচে (0x9F), তবে flash-এর datasheet যেভাবে লেখে সেভাবে command-কে কোথাও কোথাও 9Fh লেখা হয়েছে; দুটি একই মান। কোর্সের virtual বাজারঘর board BG-M3 কোনো আসল পণ্য নয়, আসল Cortex-M3 chip-এর আদলে বানানো শেখার মডেল (পর্ব ০৬; reference lab-এর README, Spec decision 17). README-র memory map-এ GPIO, UART, ADC আর একটি I2C-ধাঁচের bus আছে, কিন্তু কোনো SPI peripheral নেই। তাই SPI শেখানো হয়েছে আসল datasheet থেকে (Winbond W25Q128JV, Rev. M; ST-এর STM32F103-এর reference manual RM0008), তার আচরণ ব্রাউজারে চলা Python মডেলে, আর board-এ GPIO দিয়ে বানানো SPI-এর একটি আসল run-এ। হাতে কোনো আসল chip, board বা logic analyzer ছিল না। আগের ভিত্তি: shift register (Computer Architecture পর্ব ১৬), C-র bit operation (C পর্ব ০৯) আর GPIO (পর্ব ৪১)।

২ · দুটি shift register-এর বৃত্ত — full duplex মানে কী

SPI-এর ভেতরের যন্ত্রটি আশ্চর্য রকম সরল। Master আর slave দুজনের কাছেই একটি 8-বিট shift register. Master-এর register-এর MSB বেরিয়ে MOSI দিয়ে slave-এর register-এর অন্য প্রান্তে ঢোকে; slave-এর MSB বেরিয়ে MISO দিয়ে master-এর register-এর অন্য প্রান্তে ঢোকে। দুটি মিলে একটি ১৬ ঘরের বৃত্ত। প্রতিটি clock-এ বৃত্তটি এক ঘর ঘোরে, আর আটটি clock-এ দুই register-এর মান পুরো অদলবদল হয়। পাঠানো আর পাওয়া একই সঙ্গে ঘটে বলে একে full-duplex বলা হয়।

ছবি ৫০.১ — Master আর slave-এর shift register একটি বৃত্তে

MOSI ওপরে বাঁ থেকে ডানে, MISO নিচ দিয়ে ঘুরে ফেরে; SCK আর CS শুধু master থেকে slave-এ যায়

SPI-এর দুটি shift register-এর বৃত্ত Master (MCU) Slave (flash) MSB MSB MOSI MISO SCK CS (active low)
ছবি ৫০.১ — প্রতিটি clock-এ দুই register-এর MSB তারে যায়, আর প্রত্যেকে অন্যজনের পাঠানো বিটটি নিজের খালি প্রান্তে বসায়। আটটি clock-এ ১৬ ঘরের বৃত্ত আট ঘর ঘোরে, ফলে দুটি byte জায়গা বদল করে। Clock আর CS শুধু master-এর হাতে।

নিচের block-টি এই বৃত্তকে হুবহু কোডে বসায়। Master-এর register-এ 0x9F (একটি flash-এর পরিচয় জানার command, অংশ ৫-এ আসছে), slave-এর register-এ 0x5A. প্রতিটি clock-এ দুজনের MSB তারে যায়, আর দুজনেই এক ঘর বাঁয়ে সরে অন্যজনের বিট নিজের LSB-তে বসায়। এখানে mode 0 ধরা হয়েছে, যার পূর্ণ অর্থ অংশ ৩-এ।

# SPI-র হৃদয়: দুই প্রান্তের দুটি 8-বিট shift register, একটি বৃত্তে জোড়া
def exchange(master, slave, show=False):
    """Mode 0, MSB আগে: প্রতিটি clock-এ দুজনেই একটি বিট দেয়, একটি নেয়"""
    m, s = master, slave
    for clk in range(1, 9):
        mosi = (m >> 7) & 1            # master-এর MSB যায় MOSI তারে
        miso = (s >> 7) & 1            # slave-এর MSB যায় MISO তারে
        m = ((m << 1) & 0xFF) | miso   # rising edge: দুজনেই পাশের বিট ঢোকায়
        s = ((s << 1) & 0xFF) | mosi
        if show:
            print(f"clk {clk}: MOSI={mosi} MISO={miso}  "
                  f"master={m:08b}  slave={s:08b}")
    return m, s

m, s = exchange(0x9F, 0x5A, show=True)
print(f"master now holds 0x{m:02X}, slave now holds 0x{s:02X}")

# শুধু পড়তে চাইলেও master-কে কিছু পাঠাতে হয় (dummy byte)
m, s = exchange(0x00, 0xEF)
print(f"dummy 0x00 out, 0x{m:02X} in")

# শুধু লিখতে চাইলে যা ফেরত আসে, তা ফেলে দেওয়া হয়
m, s = exchange(0x06, 0xFF)
print(f"command 0x06 out, 0x{m:02X} in (ignored)")

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

clk 1: MOSI=1 MISO=0  master=00111110  slave=10110101
clk 2: MOSI=0 MISO=1  master=01111101  slave=01101010
clk 3: MOSI=0 MISO=0  master=11111010  slave=11010100
clk 4: MOSI=1 MISO=1  master=11110101  slave=10101001
clk 5: MOSI=1 MISO=1  master=11101011  slave=01010011
clk 6: MOSI=1 MISO=0  master=11010110  slave=10100111
clk 7: MOSI=1 MISO=1  master=10101101  slave=01001111
clk 8: MOSI=1 MISO=0  master=01011010  slave=10011111
master now holds 0x5A, slave now holds 0x9F
dummy 0x00 out, 0xEF in
command 0x06 out, 0xFF in (ignored)

MOSI কলামটি ওপর থেকে নিচে পড়লে 1, 0, 0, 1, 1, 1, 1, 1 = 0x9F; MISO কলাম 0, 1, 0, 1, 1, 0, 1, 0 = 0x5A. আট clock-এর পরে দুই register-এর মান অদলবদল হয়েছে। শেষ দুই লাইন SPI-এর দুটি নিয়ম শেখায়। কিছু পড়তে হলে master-কে কিছু পাঠাতেই হয়, কারণ master clock না দিলে বৃত্ত ঘোরে না; সাধারণত 0x00 বা 0xFF পাঠানো হয়, যাকে dummy byte বলে। আর কিছু লিখলে যা ফেরত আসে, firmware সেটি পড়ে ফেলে দেয়।

নিচের stepper একই অদলবদল clock ধরে ধরে দেখায়, শুরু CS নামার মুহূর্ত থেকে। প্রতিটি সারির মান ওপরের block-এর আসল output থেকে নেওয়া।

Master 0x9F পাঠায়, slave-এর register-এ 0x5A
ধাপ
MOSI
MISO
master
slave
  1. CS নামল। Slave জাগল, আর mode 0-এ দুজনেই প্রথম clock-এর আগেই নিজের MSB তারে রাখে: MOSI = 1 (0x9F-এর বিট 7), MISO = 0 (0x5A-এর বিট 7). SCK এখনো 0.
  2. clk 1-এর উঠতি ধার। দুজনেই একসাথে অন্যজনের বিট পড়ে আর এক ঘর বাঁয়ে সরে: master-এর ডান প্রান্তে ঢুকল 0, slave-এর ডান প্রান্তে 1. পরের নামতি ধারে দুজনে পরের বিট তারে রাখে।
  3. clk 2. MOSI = 0, MISO = 1. Master 01111101, slave 01101010; প্রতিটি register-এ এখন দুটি করে অন্যজনের বিট।
  4. clk 3. দুই তারেই 0. বৃত্তটি তিন ঘর ঘুরেছে; master-এর শেষে 010, যা 0x5A-এর প্রথম তিন বিট।
  5. clk 4, অর্ধেক পথ। MOSI = 1, MISO = 1. Master 11110101: বাঁয়ে নিজের পুরোনো শেষ চার বিট, ডানে slave-এর প্রথম চার বিট 0101.
  6. clk 5. আবার দুই তারেই 1. Slave-এর register-এ এখন পাঁচটি নতুন বিট, 10011, যা 0x9F-এর শুরু।
  7. clk 6. MOSI = 1, MISO = 0. দুই পাশে মাত্র দুটি পুরোনো বিট বাকি।
  8. clk 7. MOSI = 1, MISO = 1. Master 10101101, slave 01001111.
  9. clk 8, অদলবদল শেষ। Master-এ 01011010 = 0x5A, slave-এ 10011111 = 0x9F. এখন master CS তুলতে পারে, অথবা CS নামিয়ে রেখেই পরের byte-এর আটটি clock দিতে পারে।

৩ · CPOL আর CPHA — চারটি mode আর timing diagram

“প্রতিটি clock-এ দুজনে এক বিট দেয়” বলা সহজ, কিন্তু আসল তারে দুটি প্রশ্নের উত্তর দিতে হয়। এক, কাজ না চলার সময় SCK নিচে থাকবে না ওপরে? দুই, একটি clock pulse-এর দুটি ধারের কোনটিতে বিট পড়া হবে, আর কোনটিতে নতুন বিট তারে বসানো হবে? প্রথমটির উত্তর CPOL (clock polarity): 0 মানে অলস SCK নিচে, 1 মানে ওপরে। দ্বিতীয়টির উত্তর CPHA (clock phase): 0 মানে প্রথম ধারে পড়া আর দ্বিতীয় ধারে বদল, 1 মানে প্রথম ধারে বদল আর দ্বিতীয় ধারে পড়া। এখানে “প্রথম ধার” মানে অলস অবস্থা থেকে সরে যাওয়ার ধার (leading edge), “দ্বিতীয়” মানে ফিরে আসার ধার (trailing edge).

দুটি বিটের চারটি জোড়, তাই চারটি SPI mode, প্রচলিত নম্বর mode = 2 × CPOL + CPHA. STM32-এর reference manual RM0008-এর SPI অধ্যায়ও একই সংজ্ঞা দেয়: CPOL “controls the steady state value of the clock when no data is being transferred”, আর CPHA reset থাকলে SCK-এর প্রথম ধারটি data ধরার মুহূর্ত। নিয়মটির পেছনের যুক্তি সহজ: যে ধারে গ্রাহক পড়ে (sampling edge), তার আগে-পরে তারের মান স্থির থাকা চাই। তাই পাঠানো হয় ঠিক উল্টো ধারে, পড়ার আধা period আগে। Flip-flop-এর ভাষায় এটিই setup time আর hold time রক্ষা করা (Computer Architecture পর্ব ১৮)।

ছবি ৫০.২ — চারটি mode-এর timing diagram (প্রথম তিনটি বিট)

ওপরে CS, তারপর দুই রকম SCK, নিচে দুই রকম data. সবুজ দাগ = CPHA 0-এর পড়ার মুহূর্ত, কমলা দাগ = CPHA 1-এর

SPI-এর চারটি mode CS (নামলে লেনদেন শুরু) SCK, CPOL = 0 (mode 0, 1) SCK, CPOL = 1 (mode 2, 3) data, CPHA = 0 (mode 0, 2) data, CPHA = 1 (mode 1, 3) b7b6b5 b7b6b5 সবুজ দাগ: CPHA 0 পড়ে প্রথম ধারে কমলা দাগ: CPHA 1 পড়ে দ্বিতীয় ধারে
ছবি ৫০.২ — CPHA 0-এ প্রথম বিট (b7) CS নামতেই তারে আসে, তাই প্রথম ধারেই পড়া যায়; প্রতিটি বিট বদলায় দ্বিতীয় ধারে। CPHA 1-এ প্রতিটি বিট বদলায় প্রথম ধারে আর পড়া হয় দ্বিতীয় ধারে। দুই ক্ষেত্রেই পড়ার দাগটি বিটের ঘরের ঠিক মাঝখানে, আধা period আগে আর পরে মান স্থির। CPOL শুধু ধারগুলোর দিক উল্টায়: CPOL 0-এ প্রথম ধার উঠতি, CPOL 1-এ নামতি। ছবি ধারণা বোঝানোর জন্য আঁকা, মাপমতো নয়।

ছবি থেকে একটি গুরুত্বপূর্ণ সরলীকরণ বেরোয়। গ্রাহক আসলে “প্রথম” বা “দ্বিতীয়” ধার গোনে না, সে শুধু উঠতি না নামতি ধার চেনে। Mode 0-এ (CPOL 0) প্রথম ধার উঠতি, তাই পড়া উঠতিতে; mode 3-এ (CPOL 1) দ্বিতীয় ধার উঠতি, তাই সেখানেও পড়া উঠতিতে। অর্থাৎ mode 0 আর 3 দুটোই উঠতি ধারে পড়ে, আর mode 1 আর 2 নামতি ধারে। পার্থক্য শুধু অলস SCK-এর মান আর প্রথম বিট কখন তারে আসে। এ কারণেই W25Q128JV-এর datasheet বলে “SPI bus operation Mode 0 (0,0) and 3 (1,1) are supported”, আর লেখে যে chip DI পিনের বিট নেয় CLK-এর উঠতি ধারে আর DO-তে বিট দেয় নামতি ধারে।

Mode না মিললে কী হয়? নিচের মডেলে master 0x9F পাঠায় নিজের mode-এ, আর slave নিজের mode অনুযায়ী উঠতি বা নামতি ধারে পড়ে। সময় মাপা হয় আধা clock period-এর এককে। পড়ার মুহূর্তেই যদি তারের মান বদলায়, মডেল ধরে নেয় গ্রাহক পুরোনো মানটি পায় (বদলটি একটু দেরিতে আসে), আর h লেখে পড়ার পরে মানটি কতক্ষণ স্থির ছিল, অর্থাৎ hold margin. ok মানে সঠিক byte আর আধা period-এর margin.

# CPOL/CPHA: master যে mode-এ পাঠায় আর slave যে ধারে পড়ে, না মিললে কী হয়
# সময়ের একক = আধা clock period. CS নামে t=0-তে, SCK-এর ১৬টি ধার t=1..16
def master_changes(cpha):      # MOSI কখন নতুন বিট নেয়: [(সময়, বিটের ক্রম)]
    if cpha == 0:              # প্রথম বিট CS নামতেই, পরেরগুলো trailing ধারে
        return [(0, 0)] + [(2 * k, k) for k in range(1, 8)]
    return [(2 * k + 1, k) for k in range(8)]   # CPHA=1: leading ধারে বদল

def sample_times(cpol_clk, slave_mode):   # slave শুধু ধারের দিক চেনে
    rising = slave_mode in (0, 3)         # mode 0, 3 = rising-এ পড়ে; 1, 2 = falling-এ
    times = [t for t in range(1, 17)
             if ((t % 2 == 1) == (cpol_clk == 0)) == rising]   # CPOL 0: বিজোড় ধার উঠতি
    return times[:8]

def send(byte, m_mode, s_mode, idle=1):
    bits = [(byte >> (7 - k)) & 1 for k in range(8)]
    ch = master_changes(m_mode & 1)
    got, hold = 0, 9
    for t in sample_times(m_mode >> 1, s_mode):
        before = [k for tc, k in ch if tc < t]       # ঠিক ধারে বদল = পুরোনো মান পড়ে
        got = (got << 1) | (bits[before[-1]] if before else idle)
        nxt = [tc for tc, _ in ch if tc >= t]
        hold = min(hold, (nxt[0] - t) if nxt else 9)
    return got, hold

print("master 0x9F পাঠায়; সারি = master-এর mode, কলাম = slave-এর mode")
print("              slave0    slave1    slave2    slave3")
for mm in range(4):
    row = []
    for sm in range(4):
        got, hold = send(0x9F, mm, sm)
        tag = "ok" if hold >= 1 and got == 0x9F else f"h={hold}"
        row.append(f"0x{got:02X} {tag:<4}")
    print(f"master{mm} ({mm >> 1},{mm & 1}) " + " ".join(row))

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

master 0x9F পাঠায়; সারি = master-এর mode, কলাম = slave-এর mode
              slave0    slave1    slave2    slave3
master0 (0,0) 0x9F ok   0x9F h=0  0x9F h=0  0x9F ok
master1 (0,1) 0xCF h=0  0x9F ok   0x9F ok   0xCF h=0
master2 (1,0) 0x9F h=0  0x9F ok   0x9F ok   0x9F h=0
master3 (1,1) 0x9F ok   0xCF h=0  0xCF h=0  0x9F ok  

তিনটি শিক্ষা। প্রথমত, সারণিটি দুই ভাগে ভাঙে: উঠতি ধারে পড়া mode {0, 3} আর নামতি ধারে পড়া {1, 2}। Master 0 আর slave 3 মেলে, যেমন W25Q128JV দুটোই নেয়। দ্বিতীয়ত, master 1 (বদল উঠতি ধারে) আর slave 0 (পড়া উঠতি ধারে): প্রতিটি পড়া ঠিক বদলের মুহূর্তে, তাই slave সবসময় আগের বিট পায়। প্রথম পড়ায় তারে আছে অলস মান (মডেলে 1), পরে b7 … b1, আর b0 হারিয়ে যায়: 1 + 1001111 = 0xCF, এক ঘর সরে যাওয়া byte. তৃতীয়ত, সবচেয়ে বিপজ্জনক ঘরগুলো “0x9F h=0”: মান ঠিক এসেছে, কিন্তু hold margin শূন্য। কাগজে কাজ করে, ধীর বা ছোট তারে টেবিলে হয়তো চলেও; কিন্তু তাপমাত্রা, তারের দৈর্ঘ্য বা chip বদলালে কখনো ঠিক, কখনো ভুল। এমন bug খুঁজে পেতে দিনের পর দিন লাগে, তাই mode সবসময় datasheet থেকে মিলিয়ে নেবেন। আসল তারে এই margin দেখতে পর্ব ৩৮-এর logic analyzer লাগে।

mode = 2 × CPOL + CPHA
mode
অলস SCK
পড়ে
বদলায়
প্রথম বিট
ফল
  1. Mode 0. SCK অলস 0. প্রথম বিট CS নামতেই তারে, পড়া উঠতি ধারে, বদল নামতি ধারে। সবচেয়ে প্রচলিত mode; STM32-এর CR1-এ CPOL আর CPHA দুটোর reset মান 0, তাই কিছু না বদলালে এটিই।
  2. Mode 1. SCK এখনো অলস 0, কিন্তু CPHA 1: প্রথম (উঠতি) ধারে বিট বসে, দ্বিতীয় (নামতি) ধারে পড়া। CS নামার মুহূর্তে তারে কোনো অর্থপূর্ণ বিট নেই।
  3. Mode 2. SCK অলস 1, তাই প্রথম ধার নামতি। CPHA 0, তাই পড়া প্রথম ধারে, অর্থাৎ নামতিতে; বদল উঠতিতে। এটি mode 1-এর মতোই নামতিতে পড়ে, শুধু অলস মান আর প্রথম বিটের সময় আলাদা।
  4. Mode 3. SCK অলস 1, প্রথম (নামতি) ধারে বিট বসে, দ্বিতীয় (উঠতি) ধারে পড়া। পড়া mode 0-এর মতোই উঠতিতে, তাই W25Q128JV-এর মতো chip mode 0 আর 3 দুটোই নেয়।
  5. ভুল জোড়। Master mode 1-এ উঠতি ধারে বিট বদলায়, slave mode 0-এ উঠতি ধারেই পড়ে। প্রতিটি পড়া বদলের মুহূর্তে, hold margin শূন্য, আর মডেলে slave পায় এক ঘর পিছিয়ে থাকা 0xCF (মডেলের আসল output).

৪ · Chip select, কয়েকটি slave আর daisy chain

একটি bus-এ একাধিক slave রাখার সবচেয়ে প্রচলিত উপায়: SCK, MOSI আর MISO সবার মধ্যে ভাগ, কিন্তু প্রত্যেক slave-এর নিজের CS তার। CS উঁচু থাকা slave clock উপেক্ষা করে আর নিজের MISO pin ছেড়ে দেয়, অর্থাৎ tri-state (high impedance) অবস্থায় যায়, যাতে নির্বাচিত slave একাই MISO চালাতে পারে। এটি পুরোনো microprocessor-এর memory decoding-এর সেই একই chip select ধারণা, যেখানে address decoder ঠিক করত কোন ROM বা RAM সাড়া দেবে (পর্ব ২২); শুধু এখানে decoder-এর কাজ firmware নিজে করে, একটি GPIO নামিয়ে।

CS শুধু “কে শুনবে” বাছে না, লেনদেনের সীমাও টানে। SPI flash-এর মতো যন্ত্র CS নামাকে নতুন command-এর শুরু ধরে, আর CS ওঠাকে শেষ। W25Q128JV-এর datasheet স্পষ্ট বলে, program বা erase-এর command-এ শেষ byte-এর অষ্টম বিটের পরে CS তুলতে হবে, নইলে command কার্যকরই হবে না। তাই firmware-এ CS-এর হাতে-নাড়া সঠিক জায়গায় থাকা SPI-এর একটি বড় অংশ। আর দুটি CS একসাথে নামলে দুটি slave একই MISO তারে উল্টো মান চালাতে পারে: এটি bus contention, যেখানে ভুল data-র পাশাপাশি দুই driver-এর মধ্যে বড় current বয়ে যেতে পারে।

Cold-room monitor: CS0 = flash, CS1 = ছোট display, SCK আর MOSI দুজনের মধ্যে ভাগ
CS0 (flash)
CS1 (display)
MOSI
MISO চালায়
অবস্থা
  1. অলস bus. দুটি CS-ই 1. কোনো slave MISO চালায় না; একটি pull-up resistor থাকলে MISO পড়লে 1 আসে, তাই firmware এ সময় কিছু পড়লে 0xFF পায়।
  2. CS0 নামল, command 0x9F. শুধু flash জাগে। প্রথম আট clock-এ সে command শোনে; এই সময় তার DO থেকে আসা বিটের কোনো অর্থ নেই। Display একই SCK আর MOSI দেখছে, কিন্তু তার CS1 উঁচু, তাই সে উপেক্ষা করে।
  3. তিনটি dummy byte. Master 0x00 পাঠিয়ে clock দেয়, আর flash MISO-তে তার JEDEC ID পাঠায়: EFh, 40h, 18h (W25Q128JV-IQ/JQ, datasheet-এর সারণি অনুযায়ী)।
  4. CS0 উঠল। Flash-এর লেনদেন শেষ, সে MISO ছেড়ে দেয়। পরের command আবার CS নামিয়ে নতুন করে শুরু হবে।
  5. CS1 নামল. এখন display শোনে, তাপমাত্রার অক্ষরগুলো নেয়। অনেক display শুধু শোনে, কিছু ফেরত দেয় না; firmware MISO-র বিট ফেলে দেয়। Flash-এর CS উঁচু, তাই একই clock তার কাছে অর্থহীন।
  6. ভুল: দুটি CS একসাথে 0. দুজনেই command নেয়, যা display-এর জন্য লেখা তা flash-ও পড়ে, আর flash যদি MISO চালায় আর অন্য কোনো slave উল্টো মান চালায়, তবে bus contention. নিয়ম: এক মুহূর্তে একটি CS. RTOS-এ কয়েকটি task একই bus ব্যবহার করলে এর জন্য mutex লাগে (পর্ব ৫৭)।

CS-এর pin কম থাকলে আরেকটি উপায় daisy chain: একটি CS-এর নিচে যন্ত্রগুলো শিকলের মতো, প্রথমটির shift register-এর output পরেরটির input-এ, আর শেষটির output master-এর MISO-তে। প্রচলিত উদাহরণ 74HC595-এর মতো serial-in, parallel-out shift register chip: এর একটি serial output pin থাকে, যা পরের chip-এর data input-এ জোড়া যায়, আর আলাদা একটি latch clock পুরো মান একসাথে output pin-এ তোলে। বাজারঘরের smart scale-এর দামের display-এর মতো কয়েকটি 7-segment digit এভাবে মাত্র তিনটি pin দিয়ে চালানো যায়। দাম আছে: যেকোনো একটি যন্ত্র বদলাতে পুরো শিকলের সব বিট ঠেলে পাঠাতে হয়, আর একটি clock কম-বেশি হলে সব যন্ত্রের মান সরে যায়।

# Daisy chain: একটি CS, যন্ত্রগুলোর shift register শিকলের মতো জোড়া
# MOSI -> dev0 -> dev1 -> ... -> শেষ যন্ত্রের output -> master-এর MISO
def to_bits(data):
    return [(b >> (7 - i)) & 1 for b in data for i in range(8)]

def clock_chain(chain, bits):
    """প্রতিটি SCK-এ সবাই এক ঘর সরে; ফেরত দেয় MISO-তে আসা বিটগুলো"""
    got = []
    for carry in bits:
        for k in range(len(chain)):
            msb = (chain[k] >> 7) & 1
            chain[k] = ((chain[k] << 1) & 0xFF) | carry
            carry = msb                     # এর MSB যায় পরের যন্ত্রে
        got.append(carry)                   # শেষ যন্ত্রের MSB = MISO
    return got

def hx(xs):
    return " ".join(f"0x{x:02X}" for x in xs)

# দুটি 74HC595-ধাঁচের register; আগের মান dev0 = 0x11, dev1 = 0x22
chain = [0x11, 0x22]
got = clock_chain(chain, to_bits([0xA1, 0x3C]))
rx = [int("".join(map(str, got[i:i + 8])), 2) for i in (0, 8)]
print("sent        :", hx([0xA1, 0x3C]))
print("dev0, dev1  :", hx(chain), " <- CS উঠলে latch")
print("MISO got    :", hx(rx), " <- শিকলের পুরোনো মান")

# ভুল: 16-এর জায়গায় 15টি clock
chain = [0x00, 0x00]
clock_chain(chain, to_bits([0xA1, 0x3C])[:15])
print("15 clocks   :", hx(chain), " <- সব এক ঘর পিছিয়ে")

for n in (2, 4, 8):
    print(f"n={n}: daisy chain = 1 CS pin, {8 * n:2} clocks per update; "
          f"separate CS = {n} CS pins, 8 clocks per device")

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

sent        : 0xA1 0x3C
dev0, dev1  : 0x3C 0xA1  <- CS উঠলে latch
MISO got    : 0x22 0x11  <- শিকলের পুরোনো মান
15 clocks   : 0x9E 0x50  <- সব এক ঘর পিছিয়ে
n=2: daisy chain = 1 CS pin, 16 clocks per update; separate CS = 2 CS pins, 8 clocks per device
n=4: daisy chain = 1 CS pin, 32 clocks per update; separate CS = 4 CS pins, 8 clocks per device
n=8: daisy chain = 1 CS pin, 64 clocks per update; separate CS = 8 CS pins, 8 clocks per device

প্রথম লাইন দুটি daisy chain-এর সবচেয়ে চমকপ্রদ নিয়ম দেখায়: প্রথমে পাঠানো byte যায় শিকলের সবচেয়ে দূরের যন্ত্রে। 0xA1 আগে ঢুকেছিল, ১৬টি clock-এ সেটি dev0 পেরিয়ে dev1-এ পৌঁছেছে; 0x3C থেমেছে dev0-তে। তাই firmware-কে শেষ যন্ত্রের byte আগে পাঠাতে হয়। তৃতীয় লাইনে MISO-তে ফিরেছে শিকলের পুরোনো মান, আগে dev1-এর 0x22, পরে dev0-এর 0x11: পুরো শিকল আসলে একটি ১৬ বিটের বড় shift register. চতুর্থ লাইনে একটি clock কম দেওয়ার ফল: 0x9E আর 0x50, দুটোই ভুল, কারণ পুরো ১৬ বিটের প্রবাহ এক ঘর পিছিয়ে আছে (বাঁয়ে একটি পুরোনো 0, তারপর পাঠানো ১৫টি বিট)। শেষ তিন লাইন খরচের তুলনা: daisy chain pin বাঁচায়, কিন্তু যন্ত্র যত বাড়ে, প্রতিটি হালনাগাদে clock তত বাড়ে।

৫ · একটি আসল যন্ত্র — SPI flash-এর command আর বাজারঘরের log

এবার cold room-এর log-এর জন্য একটি আসল chip ধরে দেখা যাক: Winbond-এর W25Q128JV, ১২৮ M-bit (16 MiB)-এর একটি serial NOR flash. এখানে সব তথ্য এর datasheet-এর Revision M (ডিসেম্বর ২০২৪) থেকে। Chip-টি ৬৫,৫৩৬টি page-এ সাজানো, প্রতিটি 256 byte; একবারে 4 KiB-এর একটি sector মোছা যায়। SPI-এর ভাষায় প্রতিটি কাজ একটি লেনদেন: CS নামানো, একটি command byte, দরকার হলে 24-বিট ঠিকানা আর data, তারপর CS তোলা। নিচের সারণিতে এই পর্বে ব্যবহৃত command-গুলো।

CommandByteতারপর master পাঠায়ফল
Read JEDEC ID9Fh3টি dummy byteMISO-তে EFh (Winbond), 40h, 18h
Write Enable06hকিছু নাStatus-এর WEL বিট 1
Read Status Register-105h1টি dummy byteবিট 0 BUSY, বিট 1 WEL
Sector Erase (4 KiB)20h24-বিট ঠিকানাপুরো sector 0xFF; সাধারণত 45 ms, সর্বোচ্চ 400 ms
Page Program02hঠিকানা + 1 থেকে 256 byteলেখা; সাধারণত 0.4 ms, সর্বোচ্চ 3 ms
Read Data03hঠিকানা + যত খুশি dummyপরপর byte, MSB আগে; clock সর্বোচ্চ 50 MHz

সারণির পেছনে কয়েকটি নিয়ম, সবই datasheet-এর ভাষা থেকে। 9Fh-এর ID “JEDEC standard for SPI compatible serial memories that was adopted in 2003”-এর সঙ্গে মেলে; প্রথম byte নির্মাতার নম্বর, পরের দুটি memory-র ধরন আর ধারণক্ষমতা। এই JEDEC ID পড়া firmware-এর প্রথম কাজ: ভুল chip বা ঢিলে তার ধরা পড়ে সঙ্গে সঙ্গে, কারণ তার না থাকলে সাধারণত FF FF FF আসে। 03h দিয়ে পড়ার সময় ঠিকানা নিজে নিজে বাড়ে, তাই একটি লেনদেনেই পুরো memory পড়া যায়, যতক্ষণ clock চলে। লেখা অনেক বেশি নিয়মে বাঁধা। প্রতিটি program বা erase-এর আগে 06h দিয়ে Write Enable Latch (WEL) 1 করতে হয়, নইলে chip command নীরবে উপেক্ষা করে; কাজ শেষে WEL নিজেই 0 হয়ে যায়। Page program শুধু আগে মোছা (FFh) জায়গায় লেখে, কারণ লেখা বিটকে শুধু 1 থেকে 0 করে; তাই নতুন লেখার আগে sector erase. আর সবচেয়ে বড় ফাঁদ: ঠিকানার শেষ byte শূন্য না হলে আর data page-এর বাকি জায়গা পেরোলে, datasheet-এর ভাষায় “the addressing will wrap to the beginning of the page”, পরের page-এ নয়।

CS তোলার পরে chip নিজে নিজে লেখে বা মোছে, আর এই সময় status-এর BUSY বিট 1 থাকে। BUSY থাকাকালীন 03h-এর মতো command উপেক্ষিত হয়, তাই firmware 05h দিয়ে BUSY 0 হওয়া পর্যন্ত অপেক্ষা করে। নিচের block একটি ছোট মডেল, যা এই নিয়মগুলো কোডে বসায় (BUSY-এর সময় মডেলে নেই, সেখানে সবসময় 0). প্রতিটি xfer একটি পুরো লেনদেন: যে list যায় MOSI-তে, একই দৈর্ঘ্যের list ফেরে MISO থেকে। Log-এর প্রতিটি record 8 byte: ক্রমিক নম্বর, সেকেন্ড, তাপমাত্রার কাঁচা 16-বিট মান (reference lab-এর README-র TMP102-ধাঁচের format: 7.00 °C = 0x0700, −0.50 °C = 0xFF80), alarm-এর ধরন (1 HIGH, 2 LOW) আর একটি xor checksum. মান দুটি README-র cold room-এর আসল run-এর দুটি TELEMETRY লাইন থেকে।

# W25Q128JV-ধাঁচের SPI flash-এর ছোট মডেল (datasheet Rev. M-এর command)
class Flash:
    def __init__(self):
        self.mem, self.wel = bytearray(b"\xFF" * 8192), 0   # মডেলে 8 KiB; WEL = S1
    def xfer(self, tx):                       # CS নামা থেকে ওঠা: একটি transaction
        cmd, a = tx[0], int.from_bytes(bytes(tx[1:4]), "big")
        rx = [0xFF] * len(tx)                 # command-এর সময় DO-তে কিছু নেই
        if cmd == 0x9F: rx[1:4] = [0xEF, 0x40, 0x18]         # JEDEC ID
        elif cmd == 0x05: rx[1] = self.wel << 1              # S1 = WEL, S0 = BUSY
        elif cmd == 0x06: self.wel = 1                       # Write Enable
        elif cmd == 0x03: rx[4:] = self.mem[a:a + len(tx) - 4]
        elif cmd == 0x20 and self.wel:                       # 4 KiB sector erase
            s = a & ~0xFFF
            self.mem[s:s + 4096], self.wel = b"\xFF" * 4096, 0
        elif cmd == 0x02 and self.wel:                       # page program
            for i, d in enumerate(tx[4:]):
                self.mem[(a & ~0xFF) | ((a + i) & 0xFF)] &= d   # page-এর ভেতরে ঘোরে; 1 -> 0
            self.wel = 0
        return rx

def record(seq, t16, alarm):      # 8 byte: seq, সময় (s), t16, alarm, xor
    b = [seq >> 8, seq & 255, seq * 10 >> 8, seq * 10 & 255, t16 >> 8, t16 & 255, alarm]
    return b + [b[0] ^ b[1] ^ b[2] ^ b[3] ^ b[4] ^ b[5] ^ b[6]]

f = Flash()
print("9F ->", [hex(v) for v in f.xfer([0x9F, 0, 0, 0])[1:]])
f.xfer([0x06]); f.xfer([0x20, 0, 0, 0])                      # WREN, sector 0 মোছা
for n, (t16, al) in enumerate([(0x0700, 1), (0xFF80, 2)]):   # 7.00 C HIGH, -0.50 C LOW
    f.xfer([0x06]); f.xfer([0x02, 0, 0, 8 * n] + record(n + 1, t16, al))
    print("status after program:", hex(f.xfer([0x05, 0])[1]))
print("03 read:", f.xfer([0x03, 0, 0, 0] + [0] * 16)[4:])
f.xfer([0x02, 0, 0, 16] + record(3, 0x0400, 0))               # WREN ছাড়া!
print("no WREN, byte 16 =", hex(f.xfer([0x03, 0, 0, 16, 0])[4]))
f.xfer([0x06]); f.xfer([0x02, 0, 0, 0xFC] + record(4, 0x0400, 0))  # page-এর কিনারায়
print("at 0xFC:", f.xfer([0x03, 0, 0, 0xFC] + [0] * 4)[4:], "at 0x00:", f.xfer([0x03, 0, 0, 0] + [0] * 4)[4:])

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

9F -> ['0xef', '0x40', '0x18']
status after program: 0x0
status after program: 0x0
03 read: [0, 1, 0, 10, 7, 0, 1, 13, 0, 2, 0, 20, 255, 128, 2, 107]
no WREN, byte 16 = 0xff
at 0xFC: [0, 4, 0, 40] at 0x00: [0, 0, 0, 8]

প্রথম লাইন ID: EFh 40h 18h. “status after program: 0x0” মানে WEL আবার 0: প্রতিটি লেখার আগে নতুন করে 06h লাগে। 03h-এর ১৬টি byte দুটি record: প্রথমটি seq 1, 10 s, 0x07 0x00 (7.00 °C), alarm 1, checksum 13; দ্বিতীয়টি seq 2, 20 s, 0xFF 0x80 (255, 128 = −0.50 °C), alarm 2. এরপর দুটি ভুল। WREN ছাড়া পাঠানো page program কোনো error ছাড়াই উপেক্ষিত, byte 16 এখনো 0xFF: SPI-তে কোনো ACK নেই, তাই chip “না” বললেও master জানতে পারে না, পড়ে মিলিয়ে দেখা ছাড়া। শেষ লাইনটি সবচেয়ে শিক্ষণীয়। 0xFC-তে 8 byte লেখা হলো; প্রথম চারটি 0xFC থেকে 0xFF-এ বসেছে, বাকি চারটি পরের page-এ না গিয়ে একই page-এর শুরুতে, 0x00-তে ঘুরে গেছে। সেখানে আগে থেকে record 1 ছিল (0, 1, 0, 10); flash বিট শুধু 1 থেকে 0 করতে পারে, তাই দুটি মান মিশে (AND হয়ে) 0, 0, 0, 8. প্রথম record নষ্ট, আর firmware কোনো সংকেতও পায়নি। এখানে record 8 byte আর 256 তার গুণিতক, তাই 0 থেকে ধারাবাহিকভাবে লিখলে কখনো page পেরোয় না; কিন্তু record-এর আকার বদলালে বা ঠিকানার হিসাবে ভুল হলে এই bug ফিরে আসে (অনুশীলন ১)।

৬ · STM32F103-এর SPI peripheral — register ধরে ধরে

আসল microcontroller-এ shift register, clock-এর ভাগ আর ধারের নিয়ম hardware-এ থাকে। STM32F103-এ (RM0008, SPI অধ্যায়) SPI_CR1 register-এ বিট 0 CPHA, বিট 1 CPOL, বিট 2 MSTR (master), বিট 5–3 BR (baud rate: fPCLK ÷ 2 থেকে ÷ 256), বিট 6 SPE (চালু), বিট 7 LSBFIRST, বিট 8 SSI আর বিট 9 SSM (software দিয়ে NSS সামলানো), বিট 11 DFF (8 না 16 বিট)। Status register SR-এ বিট 0 RXNE (একটি byte এসেছে), বিট 1 TXE (পাঠানোর buffer খালি), বিট 7 BSY. ST-এর datasheet অনুযায়ী এই chip-এর SPI 18 Mbit/s পর্যন্ত (আপনার নির্দিষ্ট মডেলের datasheet দেখে নিন)। নিচের কোড SPI2 দিয়ে বাজারঘরের flash চালায়: PB13 SCK, PB14 MISO, PB15 MOSI, আর CS একটি সাধারণ GPIO, PB12.

/* STM32F103, CMSIS device header; RM0008-এর SPI অধ্যায়। hardware-এ চালানো হয়নি */
void flash_spi_init(void)
{
    RCC->APB2ENR |= 1u << 3;                     /* IOPBEN */
    RCC->APB1ENR |= 1u << 14;                    /* SPI2EN (APB1, 36 MHz) */
    GPIOB->BSRR = 1u << 12;                      /* CS আগে থেকেই 1 */
    GPIOB->CRH = (GPIOB->CRH & 0x0000FFFFu)
               | 0xB4B30000u;    /* PB15 AF-PP, PB14 input, PB13 AF-PP, PB12 GP-PP */
    SPI2->CR1 = (1u << 9) | (1u << 8)            /* SSM, SSI: NSS software-এ */
              | (1u << 3)                        /* BR = 001: 36 MHz / 4 = 9 MHz */
              | (1u << 2);                       /* MSTR; CPOL = CPHA = 0: mode 0 */
    SPI2->CR1 |= 1u << 6;                        /* SPE */
}

static uint8_t spi2_xfer(uint8_t out)
{
    while (!(SPI2->SR & (1u << 1))) { }          /* TXE */
    SPI2->DR = out;
    while (!(SPI2->SR & (1u << 0))) { }          /* RXNE: অদলবদল শেষ */
    return (uint8_t)SPI2->DR;
}

void flash_read_id(uint8_t id[3])
{
    GPIOB->BRR = 1u << 12;                       /* CS = 0 */
    (void)spi2_xfer(0x9Fu);
    for (int i = 0; i < 3; i++) id[i] = spi2_xfer(0x00u);   /* dummy byte */
    while (SPI2->SR & (1u << 7)) { }             /* BSY = 0 হলে */
    GPIOB->BSRR = 1u << 12;                      /* CS = 1 */
}

এটি একটি উদাহরণ, কোনো board-এ চালানো হয়নি; বিটগুলো RM0008 থেকে মেলানো। কয়েকটি কারণ বোঝা দরকার। প্রথমত SSM আর SSI: hardware NSS pin ব্যবহার না করলে SSI = 1 দিয়ে peripheral-কে জানাতে হয় “আমি নির্বাচিত নই”; নইলে master নিজের NSS-কে নিচু দেখে mode fault (MODF) ধরে আর RM0008 অনুযায়ী MSTR আর SPE মুছে দেয়, ফলে SPI কোনো error ছাড়াই থেমে যায়। দ্বিতীয়ত pin-এর nibble: 0xB = alternate function push-pull, 50 MHz, যাতে SCK আর MOSI timer-এর মতো peripheral-এর হাতে যায়; MISO একটি input (0x4, floating); আর CS (0x3) সাধারণ push-pull output, যা firmware নিজে চালায় (পর্ব ৪১)। তৃতীয়ত BR: SPI2 থাকে APB1-এ (সর্বোচ্চ 36 MHz), তাই BR = 001 মানে 9 MHz, W25Q128JV-এর 03h-এর 50 MHz সীমার অনেক নিচে। SPI1 APB2-তে (72 MHz) থাকলে একই BR দিত 18 MHz. চতুর্থত spi2_xfer: DR-এ লেখা মানে আটটি clock শুরু, আর RXNE মানে অদলবদল শেষ; প্রতিটি পাঠানো byte-এর জন্য একটি পড়া, ঠিক অংশ ২-এর বৃত্তের মতো। পড়া বাদ দিলে পরের বার OVR (overrun) flag ওঠে। শেষে CS তোলার আগে BSY-এর অপেক্ষা, কারণ RM0008 SPI বন্ধ করার আগে TXE = 1 আর তারপর BSY = 0 হওয়ার অপেক্ষা করতে বলে; শেষ বিট পুরো বেরোনোর আগে CS তুললে slave শেষ byte হারাতে পারে।

একটি ব্যবহারিক কথা: spi2_xfer প্রতিটি byte-এ CPU-কে আটকে রাখে। 9 MHz-এ একটি byte মাত্র প্রায় 0.9 µs, তাই ছোট লেনদেনে এটিই সহজ। কিন্তু 03h দিয়ে একটি পুরো page পড়তে (1 + 3 + 256) × 8 = 2080 বিট, 9 MHz-এ 231.11 µs; বড় display-এর frame-এ আরও অনেক। তখন DMA দিয়ে SPI-এর DR থেকে buffer-এ byte সরানো হয়, CPU-কে মুক্ত রেখে (পর্ব ৪৬, DMA).

৭ · বাজারঘর board-এ bit-banged SPI — আসল run

কোর্সের board-এ SPI peripheral নেই, কিন্তু GPIO আছে। তাই এখানে bit-banging: firmware নিজে pin তুলে-নামিয়ে mode 0 বানায়। PA1 = SCK, PA2 = MOSI, PA3 = CS. Board-এ কোনো slave chip নেই, তাই MISO হিসেবে একটি loopback test: MOSI-র তারকে MISO-তে জোড়া ধরে firmware MOSI pin-টিই IDR থেকে পড়ে (Spec decision 23 অনুযায়ী IDR output pin-এর মানও দেখায়)। সঠিক হলে যা পাঠানো, ঠিক তা-ই ফেরে। আসল board-এ নতুন SPI driver যাচাইয়ের প্রথম ধাপও প্রায়ই এটি: MOSI আর MISO একটি তারে জুড়ে দেওয়া। আমার lab-এর bbspi.c-এর মূল অংশ (reference lab-এর bazarghar.h আর bglib.h ব্যবহার করে):

#define SCK_PIN  1u
#define MOSI_PIN 2u
#define CS_PIN   3u
#define MISO_PIN MOSI_PIN            /* loopback: board-এ slave নেই */

static inline void pin_write(uint32_t p, uint32_t v)
{
    if (v) GPIOA->BSRR = 1u << p;    /* শুধু set   */
    else   GPIOA->BRR  = 1u << p;    /* শুধু reset */
}

static uint8_t spi_xfer(uint8_t out)
{
    uint8_t in = 0;
    for (int i = 7; i >= 0; i--) {
        pin_write(MOSI_PIN, (out >> i) & 1u);  /* SCK নিচে: বিট তারে */
        pin_write(SCK_PIN, 1u);                /* উঠতি ধার: পড়া */
        in = (uint8_t)((in << 1) | ((GPIOA->IDR >> MISO_PIN) & 1u));
        pin_write(SCK_PIN, 0u);                /* নামতি ধার */
    }
    return in;
}
/* main: CS আগে 1, তিনটি pin output; CS = 0, spi_xfer(0x9F), CS = 1, UART-এ ফল */

লক্ষ করুন, CS-কে output করার আগেই BSRR দিয়ে 1 বসানো: নইলে DIR লেখার মুহূর্তে CS এক ঝলক 0 হয়ে slave-কে ভুল লেনদেন শুরু করাত। আর pin_write শুধু BSRR বা BRR-এ লেখে, কোনো read-modify-write নয় (পর্ব ৩৫)। Build আর run:

সত্যিকারের run · Clang 22.1.8 (ziglang 0.17.1), Unicorn 2.1.4, বাজারঘর board BG-M3
$ python -B bd.py build fw/bbspi.c -o build/bbspi.elf
built build/bbspi.elf
$ python -B bd.py run build/bbspi.elf
[     0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[     0.0035 ms] GPIO PA3 = 1
[     0.0036 ms] GPIO PA3 = 0
[     0.0045 ms] GPIO PA2 = 1
[     0.0046 ms] GPIO PA1 = 1
[     0.0049 ms] GPIO PA1 = 0
[     0.0050 ms] GPIO PA2 = 0
[     0.0051 ms] GPIO PA1 = 1
[     0.0054 ms] GPIO PA1 = 0
[     0.0056 ms] GPIO PA1 = 1
[     0.0063 ms] GPIO PA1 = 0
[     0.0064 ms] GPIO PA2 = 1
[     0.0065 ms] GPIO PA1 = 1
[     0.0067 ms] GPIO PA1 = 0
[     0.0070 ms] GPIO PA1 = 1
[     0.0076 ms] GPIO PA1 = 0
[     0.0079 ms] GPIO PA1 = 1
[     0.0084 ms] GPIO PA1 = 0
[     0.0086 ms] GPIO PA1 = 1
[     0.0090 ms] GPIO PA1 = 0
[     0.0092 ms] GPIO PA1 = 1
[     0.0103 ms] GPIO PA1 = 0
[     0.0109 ms] GPIO PA3 = 1
[     0.0398 ms] UART: sent 0x9F, received 0x9F
[     0.0406 ms] exit(0) after 325 cycles

bd.py হলো reference lab-এর board.py-এর একটি ছোট wrapper, যা শুধু Zig-এর cache আর compiler-এর temp folder আমার lab-এর ভেতরে রাখে; board-এর কোড অপরিবর্তিত। Board শুধু অবস্থা বদলালে GPIO লাইন ছাপে, তাই MOSI-র লাইন মাত্র তিনটি: 0x9F = 10011111-এ বিট 7-এ 1, বিট 6-এ 0, বিট 4-এ আবার 1, তারপর আর বদল নেই। SCK-এর আটটি উঠতি ধার গুনে মিলিয়ে নিন। Log-এর সময় 4 দশমিকের ms (Spec decision 31), যা এক cycle-এর চেয়ে মোটা; তাই --trace 400 দিয়ে প্রতিটি নির্দেশ ছাপিয়ে (board-এ এক নির্দেশ = এক cycle, Spec decision 17) আমার lab-এর edges.py প্রতিটি ধারের ঠিক cycle বের করেছে:

সত্যিকারের run · Python 3.13.5
$ python -B edges.py trace.out
cycle  28 (+ 28): CS = 1
cycle  29 (+  0): CS = 0
cycle  36 (+  7): MOSI = 1
cycle  37 (+  8): SCK rise, MOSI=1 -> bit sampled
cycle  39 (+ 10): SCK fall
cycle  40 (+ 11): MOSI = 0
cycle  41 (+ 12): SCK rise, MOSI=0 -> bit sampled
cycle  43 (+ 14): SCK fall
cycle  45 (+ 16): SCK rise, MOSI=0 -> bit sampled
cycle  50 (+ 21): SCK fall
cycle  51 (+ 22): MOSI = 1
cycle  52 (+ 23): SCK rise, MOSI=1 -> bit sampled
cycle  54 (+ 25): SCK fall
cycle  56 (+ 27): SCK rise, MOSI=1 -> bit sampled
cycle  61 (+ 32): SCK fall
cycle  63 (+ 34): SCK rise, MOSI=1 -> bit sampled
cycle  67 (+ 38): SCK fall
cycle  69 (+ 40): SCK rise, MOSI=1 -> bit sampled
cycle  72 (+ 43): SCK fall
cycle  74 (+ 45): SCK rise, MOSI=1 -> bit sampled
cycle  82 (+ 53): SCK fall
cycle  87 (+ 58): CS = 1
SCK periods (cycles): [4, 4, 7, 4, 7, 6, 5]
CS low for 58 cycles = 7.250 us; mean SCK period 5.29 cycles -> 1514 kHz (board model)
PA1 SCK, PA2 MOSI (loopback = MISO), PA3 CS; সময় CS নামার পর থেকে cycle-এ
cycle
ঘটনা
MOSI
in (জমা বিট)
SCK period
  1. CS নামল, cycle 29-এ (log-এ 0.0036 ms). এর আগে cycle 28-এ CS output হয়েছে আগে থেকে বসানো 1 নিয়ে, তাই কোনো ভুল ঝলক নেই।
  2. প্রথম বিট। +7-এ MOSI = 1 (0x9F-এর বিট 7), পরের cycle-এই SCK ওঠে, আর firmware IDR থেকে 1 পড়ে। CS থেকে প্রথম ধার পর্যন্ত ৮ cycle: function-এ ঢোকা আর register-এর ঠিকানা তৈরি।
  3. দ্বিতীয় বিট। SCK নামে, MOSI = 0 হয়, SCK ওঠে: in = 10. প্রথম দুই উঠতি ধারের ব্যবধান 4 cycle.
  4. তৃতীয় বিট। বিট 5-ও 0, তাই MOSI বদলায় না, log-এ MOSI-র কোনো লাইন নেই। in = 100.
  5. চতুর্থ বিট। +22-এ MOSI = 1, +23-এ SCK ওঠে: in = 1001. এবার ব্যবধান 7 cycle, কারণ compiler এখানে আগের বিটের হিসাবের কয়েকটি নির্দেশ ঢুকিয়েছে।
  6. শেষ চারটি বিট। সবই 1, MOSI স্থির। উঠতি ধার +27, +34, +40, +45-এ; period 4, 7, 6, 5 cycle. in = 10011111.
  7. লেনদেন শেষ। +53-এ শেষ নামতি ধার, +58-এ CS = 1. মোট 58 cycle = 7.25 µs (board-এর মডেলে)। UART: sent 0x9F, received 0x9F.

সবচেয়ে বড় শিক্ষা: SCK-এর period 4 থেকে 7 cycle পর্যন্ত লাফিয়েছে, high অংশ কখনো 2 cycle, কখনো 8, তবু ফল নিখুঁত। কারণ slave ঘড়ি ধরে সময় মাপে না, শুধু ধার দেখে। একই অসম ছন্দ UART-এ বিপর্যয় হতো, কারণ সেখানে গ্রাহক নিজের ঘড়িতে প্রতিটি বিটের মাঝখান খোঁজে। তবে সীমা আছে: প্রতিটি slave-এর datasheet ন্যূনতম high আর low সময় আর সর্বোচ্চ clock বলে দেয়, যা ধীর bit-banging সহজেই মানে। এই অসমতা কোথা থেকে এল, তা compiler-এর output বলে দেয়। clang -S --target=thumbv7m-none-eabi -mcpu=cortex-m3 -O2 (Clang 22.1.8) loop-টি পুরো খুলে ফেলেছে, আর 0x9F একটি constant বলে প্রতিটি বিটের BSRR বা BRR আগেই বেছে রেখেছে (প্রথম কয়েকটি নির্দেশ, directive বাদ):

	movw	r1, #2064         @ 0x0810
	movt	r1, #16385        @ 0x4001 -> r1 = BSRR (0x40010810)
	mov.w	lr, #4            @ 1u << 2: MOSI
	movs	r2, #2            @ 1u << 1: SCK
	str.w	lr, [r1]          @ BSRR: MOSI = 1 (বিট 7)
	str	r2, [r1]          @ BSRR: SCK = 1
	ldr	r12, [r1, #-8]    @ IDR (0x40010808) পড়া
	str	r2, [r1, #4]      @ BRR: SCK = 0
	str.w	lr, [r1, #4]      @ BRR: MOSI = 0 (বিট 6)
	str	r2, [r1]          @ BSRR: SCK = 1

কোনো loop counter নেই, কোনো shift নেই; শুধু store আর load. পড়া বিটগুলো জোড়া লাগানোর and, orr আর add নির্দেশ compiler পরের store-গুলোর ফাঁকে ফাঁকে বসিয়েছে, তাই কোনো কোনো period লম্বা। volatile register-এর store আর load-এর ক্রম অবশ্য অক্ষত (পর্ব ৩৪)। মনে রাখুন, 1514 kHz সংখ্যাটি board-এর মডেলের (Spec decision 17: এক নির্দেশ এক cycle). আসল Cortex-M3-এ peripheral bus-এর প্রতিটি store-এ বাড়তি cycle লাগতে পারে, তাই আসল bit-banged SPI এর চেয়ে ধীর হবে; সঠিক সংখ্যা আসল chip-এ logic analyzer দিয়ে মাপতে হয়।

সাবধান — bit-banging আর interrupt: এই run-এ কোনো interrupt ছিল না। আসল firmware-এ লেনদেনের মাঝখানে একটি ISR এলে SCK কিছুক্ষণ এক অবস্থায় আটকে থাকে। SPI-তে এটি সাধারণত নিরাপদ, কারণ slave শুধু ধার দেখে; কিন্তু ISR যদি একই bus-এ অন্য slave-এর সঙ্গে কথা বলে, তবে আধা-লেনদেনের মাঝে CS আর তারের অবস্থা গুলিয়ে যায়। নিয়ম: একটি bus-এর লেনদেন হয় পুরোটা task-এ, নয় পুরোটা একটি জায়গায় সুরক্ষিত (পর্ব ৪৩)।

৮ · গতি, তারের দৈর্ঘ্য আর UART ও I2C-এর সঙ্গে তুলনা

SPI কত দ্রুত চলতে পারে? Protocol নিজে কোনো সীমা দেয় না; সীমা আসে দুই প্রান্তের chip আর তার থেকে। W25Q128JV-এর datasheet সাধারণ command-এ 3.0–3.6 V-এ 133 MHz পর্যন্ত বলে, কিন্তু সাধারণ 03h Read Data-তে মাত্র 50 MHz. STM32F103-এর SPI 18 Mbit/s-এ থামে। আর বোর্ডের তারও একটি সীমা: MISO-র বিটকে master-এর SCK থেকে slave পর্যন্ত যেতে হয়, slave-কে নতুন বিট বের করতে হয় (datasheet-এর “Clock Low to Output Valid”, এই chip-এ সর্বোচ্চ 6 ns), তারপর বিটটিকে ফিরে আসতে হয়, আর এসব আধা period-এর মধ্যে, কারণ master পরের ধারেই পড়ে। 50 MHz-এ period 20 ns, আধা period 10 ns: বড় তার বা ধীর buffer থাকলে margin ফুরিয়ে যায়। তাই দ্রুত SPI ছোট PCB trace-এ চলে।

বেশি গতি দরকার হলে তার বাড়ানো হয়। Quad SPI (QSPI)-তে চারটি data তার একসাথে চলে, প্রতি clock-এ চার বিট; W25Q128JV-ও Dual আর Quad SPI command সমর্থন করে। অনেক microcontroller এমন flash থেকে সরাসরি code চালাতে পারে (execute in place), যেন flash-টি memory map-এরই অংশ। নিচের সারণিতে এই মডিউলের তিনটি প্রধান serial interface পাশাপাশি; বিস্তারিত পর্ব ৪৯ (UART) আর পর্ব ৫১ (I2C)-এ।

বিষয়UARTSPII2C
তার (GND ছাড়া)TX, RXSCK, MOSI, MISO + প্রতি slave-এ CSSDA, SCL
Clockনেই; দুই পাশে একই baud rateMaster দেয়Master দেয়, slave থামাতে পারে
দিকFull duplexFull duplexHalf duplex
যন্ত্র বাছাইসাধারণত এক জোড়াCS তার7-বিট ঠিকানা
প্রাপ্তি স্বীকারনেই (parity ঐচ্ছিক)নেইপ্রতি byte-এ ACK/NACK
সাধারণ গতি9600 থেকে 115200 baud, কখনো বেশিকয়েক MHz থেকে কয়েক দশ MHz100 kHz, 400 kHz, 1 MHz
সাধারণ ব্যবহারDebug console, GPS, modemFlash, SD card, display, দ্রুত ADCSensor, EEPROM, ছোট config chip

বাজারঘরের নকশায় তাই ভাগাভাগিটি স্বাভাবিক: তাপমাত্রার sensor I2C-তে (ধীর, অল্প data, ঠিকানায় চেনা), log-এর flash SPI-তে (দ্রুত, অনেক data), আর debug-এর লাইন UART-এ। CAN, RS-485, USB আর 1-Wire-এর মতো বাকি interface আসছে পর্ব ৫২ আর ৫৩-এ।

আরও গভীরে: SPI-এর কোনো আনুষ্ঠানিক মানদণ্ড নেই; নামটি আর ধারণাটি ১৯৮০-এর দশকে Motorola-র microcontroller থেকে ছড়িয়েছে বলে সাধারণত বলা হয়, আর National Semiconductor-এর Microwire-এর মতো কাছাকাছি নিয়মও তখন চলত। তাই “SPI”-এর নিশ্চিত সংজ্ঞা শেষ পর্যন্ত প্রতিটি chip-এর datasheet. এই শূন্যতা কিছুটা পূরণ করেছে memory-র জগতের মানদণ্ড: JEDEC-এর ID command, আর অনেক নতুন flash-এ SFDP (Serial Flash Discoverable Parameters) নামের একটি সারণি, যা পড়ে firmware নিজেই chip-এর আকার আর command জেনে নিতে পারে (নির্দিষ্ট chip সমর্থন করে কি না, datasheet দেখুন)।

পরীক্ষা ও ইন্টারভিউতে: (১) “SPI-এর চারটি সংকেত আর কে চালায়?” → SCK, MOSI, CS master চালায়; MISO নির্বাচিত slave. (২) “SPI mode 3 মানে?” → CPOL 1 (অলস SCK উঁচু), CPHA 1 (দ্বিতীয় ধারে পড়া, যা উঠতি)। (৩) “SPI কেন full duplex, আর শুধু পড়তে চাইলে কী করবেন?” → দুটি shift register প্রতিটি clock-এ বিট অদলবদল করে; পড়তে dummy byte পাঠাতে হয়। (৪) “72 MHz APB2, BR = 010 হলে SPI1-এর clock?” → 72 ÷ 8 = 9 MHz. (৫) “SPI বনাম I2C?” → SPI দ্রুত, full duplex, ঠিকানা আর ACK নেই, প্রতি slave-এ CS; I2C দুই তারে ঠিকানা দিয়ে অনেক যন্ত্র, ACK আছে, ধীর।

৯ · AI-এর যুগে SPI-এর কোড যাচাই

AI assistant-কে “STM32-এ SPI flash পড়ার কোড দিন” বললে প্রায় সবসময় compile হওয়া কোড আসে। কিন্তু SPI-এর ভুলগুলো compile-এ ধরা পড়ে না: ভুল mode-এ কাজ কখনো চলে কখনো চলে না, WEL ভোলা লেখা নীরবে হারায়, আর CS-এর ভুল সময় শেষ byte খেয়ে ফেলে। সবচেয়ে চেনা ভুল আর ধরার উপায়:

AI প্রায়ই যা করেকীভাবে ধরবেন
CPOL আর CPHA গুলিয়ে ফেলে, বা “mode 3 = CPOL 0, CPHA 1”-এর মতো ভুল নম্বর দেয়Slave-এর datasheet-এর timing diagram দেখে কোন ধারে data পড়ে তা নিজে ঠিক করুন; অংশ ৩-এর মডেলে জোড়টি চালিয়ে দেখুন
F4-এর register বা pin-এর alternate function দিয়ে F1-এর SPI সাজায়, বা SSM দিলেও SSI ভোলেনির্দিষ্ট chip-এর reference manual (F1: RM0008) আর datasheet-এর pin সারণি মেলান; MODF flag পড়ে দেখুন
শুধু লেখার সময় RX পড়ে না, তাই OVR; বা শেষ byte-এর পরে BSY না দেখেই CS তোলেপ্রতিটি পাঠানো byte-এর জন্য একটি পড়া আছে কি না দেখুন; CS তোলার আগে BSY-এর অপেক্ষা
Flash-এ program-এর আগে 06h ভোলে, 06h আর 02h একই CS-এর মধ্যে পাঠায়, বা BUSY-এর অপেক্ষা বাদ দেয়Datasheet-এর ধারা মিলিয়ে নিন; লেখার পরে 03h দিয়ে পড়ে তুলনা করুন
Page-এর সীমা না ভেবে যেকোনো ঠিকানা থেকে অনেক byte লেখেঠিকানা আর দৈর্ঘ্য থেকে page-এর সীমা হিসাব করুন; অংশ ৫-এর মডেলে পরীক্ষা করুন
Chip-এর command, ID বা সময় বানিয়ে বলে (যেমন ভুল JEDEC ID বা erase time)নির্মাতার বর্তমান datasheet-এর সারণি থেকে প্রতিটি সংখ্যা মিলিয়ে নিন; firmware-এ আসল ID পড়ে তুলনা করুন

AI-কে কাজে লাগাতে chip, clock, pin আর slave-এর datasheet-এর তথ্য শুরুতেই দিন, আর যাচাইয়ের শর্ত বেঁধে দিন:

আমি STM32F103-এর জন্য bare-metal C লিখছি (CMSIS header, HAL ছাড়া), reference manual RM0008. SPI2 (APB1 = 36 MHz): PB13 SCK, PB14 MISO, PB15 MOSI, PB12 সাধারণ GPIO-তে CS. Slave একটি W25Q128JV SPI flash; datasheet অনুযায়ী mode 0 আর 3 সমর্থিত, 03h-এ সর্বোচ্চ 50 MHz. ১. Mode 0, MSB আগে, 9 MHz-এ SPI2 সাজাও; CR1-এর প্রতিটি বিট কেন, এক লাইনে বলবে। SSM আর SSI কেন লাগে, বুঝিয়ে দেবে। ২. একটি spi2_xfer() লেখো, যা প্রতিটি পাঠানো byte-এর জন্য একটি byte পড়ে, আর CS তোলার আগে BSY-এর অপেক্ষা করে। ৩. flash_write(addr, buf, len) লেখো, যা page-এর সীমায় ভাগ করে, প্রতিটি অংশের আগে আলাদা CS-এ 06h পাঠায়, আর 05h দিয়ে BUSY 0 হওয়া পর্যন্ত অপেক্ষা করে। ৪. কোনো register-এর বিট, pin-এর alternate function বা flash-এর সময় নিয়ে নিশ্চিত না হলে "নিশ্চিত নই, RM0008 বা datasheet দেখুন" লিখবে; F4-এর MODER বা AFR ব্যবহার করবে না।

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

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

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

প্র ০১SPI-তে কোনো ঠিকানা নেই, কোনো ACK নেই, কোনো আনুষ্ঠানিক মানদণ্ডও নেই। তবু এটি flash, SD card আর display-এর প্রধান ভাষা হলো কেন? এই সরলতার দাম কী?

SPI-এর উৎস নিয়ে সাধারণভাবে বলা হয়, ১৯৮০-এর দশকে Motorola তার microcontroller-এর পাশে বাইরের ছোট chip জোড়ার জন্য এই নামের interface ছড়িয়ে দেয়; একই সময়ে National Semiconductor-এর Microwire-এর মতো কাছাকাছি নিয়মও ছিল, আর Philips ১৯৮২ সালে I2C আনে। SPI কোনো সংস্থার প্রকাশিত মানদণ্ড হয়নি, chip-নির্মাতারা একে অন্যের আচরণ মিলিয়ে নিয়েছে। তাই আজও SPI-এর “সংজ্ঞা” প্রতিটি datasheet-এর timing diagram.

এই অনানুষ্ঠানিকতাই এর শক্তি। SPI-এর ভেতরে শুধু একটি shift register আর একটি clock-এর নিয়ম; কোনো ঠিকানার decoder নেই, ACK-এর জন্য তারের দিক বদলানো নেই, open-drain bus-এর pull-up-এর জন্য ধীর ওঠা নেই। ফলে silicon-এ এর খরচ প্রায় শূন্য, আর গতি সীমিত শুধু chip আর তারের পদার্থবিদ্যায়। Flash-এর মতো যন্ত্র, যেখানে একবারে হাজার হাজার byte পড়তে হয়, ঠিক এটাই চায়: অংশ ৬-এর হিসাবে 9 MHz-এ একটি পুরো page 231.11 µs.

দামগুলোও স্পষ্ট। প্রথমত তার: প্রতিটি slave-এর জন্য একটি CS, তাই দশটি যন্ত্রে দশটি বাড়তি pin, যা I2C দুটি তারে সারে। দ্বিতীয়ত নিশ্চয়তার অভাব: ACK না থাকায় chip না থাকলেও master কিছু টের পায় না, MISO-তে শুধু 0xFF বা 0x00 আসে; অংশ ৫-এর মডেলে WREN ছাড়া লেখা নীরবে হারিয়েছে। তাই SPI-তে নিশ্চয়তা আসে উঁচু স্তর থেকে: JEDEC ID পড়ে chip চেনা, status register দেখা, লেখার পরে পড়ে মিলিয়ে নেওয়া, আর data-য় checksum বা CRC রাখা।

মূল উপলব্ধি: SPI-এর সরলতা তাকে সস্তা আর দ্রুত বানিয়েছে, কিন্তু ঠিকানা, ACK আর মানদণ্ডের কাজগুলো firmware আর datasheet-এর ওপর চাপিয়ে দিয়েছে।

প্র ০২চারটি mode কেন আছে, আর একটি flash কীভাবে mode 0 আর mode 3 দুটোই নিতে পারে অথচ mode 1 নিতে পারে না? আসল পার্থক্যটা কোথায়?

চারটি mode-এর জন্ম আলাদা chip-এর আলাদা অভ্যাস থেকে। কিছু peripheral উঠতি ধারে data নিত, কিছু নামতি ধারে; কিছু master অলস অবস্থায় clock নিচে রাখত, কিছু ওপরে। SPI-কে সব যন্ত্রের সঙ্গে কথা বলাতে microcontroller-এর SPI peripheral-গুলোতে দুটি সেটিং যোগ হলো, CPOL আর CPHA, আর তাদের চার জোড়কে নম্বর দেওয়া হলো mode 0 থেকে 3.

অংশ ৩-এর মডেলের সারণি আসল পার্থক্য দেখিয়েছে। গ্রাহক “প্রথম” বা “দ্বিতীয়” ধার গোনে না; তার ভেতরের flip-flop শুধু একটি দিকের ধারে বিট ধরে। Mode 0 আর 3 দুটোতেই পড়া উঠতি ধারে, আর পাঠানো নামতি ধারে; mode 1 আর 2-তে উল্টো। W25Q128JV-এর datasheet ঠিক এভাবেই বলে: DI-এর বিট CLK-এর উঠতি ধারে নেওয়া হয়, DO-তে বিট যায় নামতি ধারে। এই chip-এর কাছে mode 0 আর mode 3-এর পার্থক্য শুধু CS নামা আর ওঠার মুহূর্তে CLK কোথায় থাকে: mode 0-এ নিচে, mode 3-এ ওপরে। Datasheet-এর ভাষায়, “For Mode 0, the CLK signal is normally low on the falling and rising edges of /CS. For Mode 3, the CLK signal is normally high”.

Mode 1-এর master উঠতি ধারে MOSI বদলায়, ঠিক যে মুহূর্তে flash পড়ে। মডেলে তার ফল দুই রকম: hold margin শূন্য আর byte এক ঘর সরে যাওয়া (0x9F থেকে 0xCF). আর উল্টো দিকে, mode 2-এর master-এর সঙ্গে সারণিতে “0x9F h=0” এসেছে: মান ঠিক, কিন্তু margin শূন্য। এই দ্বিতীয় ধরনটিই আসল জীবনের ভয়ংকর bug: ঘরের তাপমাত্রায় টেবিলে কাজ করে, কিন্তু অন্য তাপমাত্রায়, লম্বা তারে বা অন্য উৎপাদন-ব্যাচের chip-এ মাঝে মাঝে একটি বিট ভুল। Logic analyzer-এ ধার আর data-র ব্যবধান মাপা, বা datasheet-এর setup আর hold time-এর সঙ্গে মেলানো ছাড়া এটি ধরা প্রায় অসম্ভব।

মূল উপলব্ধি: গ্রাহকের কাছে mode মানে শুধু “কোন দিকের ধারে পড়ি”; mode 0 আর 3 এ বিষয়ে এক, তাই অনেক chip দুটোই নেয়, আর ভুল mode কখনো ভুল byte দেয়, কখনো আরও খারাপ, শূন্য margin-এর “ঠিক” byte.

প্র ০৩Board-এর bit-banged SPI-তে SCK-এর period 4 থেকে 7 cycle লাফিয়েছে, তবু byte নিখুঁত এসেছে। একই অসমতা UART-এ কেন বিপর্যয়? আর hardware SPI থাকলে bit-banging কখন তবু যুক্তিসংগত?

পার্থক্যটি synchronous আর asynchronous যোগাযোগের মূলে। UART-এ (পর্ব ৪৯) গ্রাহক start বিটের ধার দেখে নিজের ঘড়ি চালু করে, তারপর প্রতিটি বিটের মাঝখানে, অর্থাৎ নির্দিষ্ট সময় পরপর, তার পড়ে। প্রেরকের একটি বিট যদি অন্যগুলোর চেয়ে ৫০% লম্বা হয়, গ্রাহক তা জানে না; তার ঘড়ি পরের বিটের জায়গায় পুরোনো বিট পড়বে। তাই UART-এ দুই পাশের baud rate কয়েক শতাংশের মধ্যে মিলতে হয়, আর bit-banged UART-এ প্রতিটি বিটের সময় নিখুঁত হওয়া চাই, যা interrupt থাকলে কঠিন।

SPI-তে গ্রাহকের নিজের কোনো ঘড়ি নেই। Master-এর প্রতিটি ধারই বলে দেয় “এখন পড়ার সময়”। এই পর্বের আসল run-এ উঠতি ধারগুলো এসেছে CS-এর পরে 8, 12, 16, 23, 27, 34, 40, 45 cycle-এ; ব্যবধান অসমান, কিন্তু প্রতিটি উঠতি ধারের আগে MOSI স্থির ছিল, আর loopback-এ 0x9F ঠিক ফিরেছে। গ্রাহকের দুটি শর্ত শুধু: প্রতিটি পড়ার ধারের আগে-পরে data স্থির (setup আর hold), আর SCK-এর high ও low অংশ datasheet-এর ন্যূনতম সময়ের বেশি। Firmware যত ধীর, এই দুটি তত সহজে মেলে।

তবু hardware SPI-ই সাধারণত প্রথম পছন্দ। Bit-banging-এ CPU প্রতিটি ধারে ব্যস্ত; board-এর মডেলে এক byte-এ 58 cycle, আর আসল Cortex-M3-এ peripheral-এ প্রতিটি store-এর বাড়তি খরচে আরও বেশি। Hardware SPI 18 Mbit/s পর্যন্ত যায়, DMA-র সঙ্গে CPU-কে প্রায় মুক্ত রাখে, আর প্রতিটি ধার নিখুঁত। Bit-banging যুক্তিসংগত যখন hardware SPI-এর pin অন্য কাজে আটকে আছে, chip-এ যথেষ্ট SPI নেই, slave-এর অদ্ভুত চাহিদা আছে (যেমন ৯ বিটের word বা একটি অস্বাভাবিক CS-এর নিয়ম), বা board তৈরির আগে একটি দ্রুত পরীক্ষা চাই।

মূল উপলব্ধি: SPI-এর clock ডেটার সঙ্গে চলে বলে অসম ছন্দও চলে, যা UART-এ চলে না; তবু CPU-র সময় আর গতির জন্য hardware SPI প্রথম পছন্দ, bit-banging সীমিত বা বিশেষ পরিস্থিতির জন্য।

প্র ০৪বাজারঘরের cold room-এর log যদি প্রতি ১০ সেকেন্ডে 8 byte-এর একটি record SPI flash-এ লেখে, তবে কয়েক বছর চলার জন্য firmware-এর নকশায় কী কী ভাবতে হবে? বিদ্যুৎ চলে গেলে কী হবে?

প্রথমে সংখ্যা, Python-এ হিসাব করা। প্রতি ১০ সেকেন্ডে একটি record মানে দিনে 8640টি, অর্থাৎ 69120 byte. 16 MiB-এর W25Q128JV তাই প্রায় 242.73 দিনে ভরে। একটি 4 KiB sector-এ 512টি record, প্রায় 85.33 মিনিটের log; দিনে মোছা লাগে প্রায় 16.875টি sector. পুরো chip-কে একটি বৃত্তাকার log বানালে প্রতিটি sector প্রায় 243 দিনে একবার মোছা হয়, আর datasheet প্রতি sector-এ অন্তত ১ লাখ program-erase চক্রের কথা বলে। কিন্তু একই sector বারবার মুছলে, যেমন সবসময় sector 0-তে একটি “সর্বশেষ অবস্থান” লিখলে, সেই sector অনেক আগেই ক্ষয়ে যেত। তাই নিয়ম: লেখা ছড়িয়ে দিন (wear levelling-এর সরল রূপ), আর কোনো একটি জায়গায় বারবার লিখবেন না।

দ্বিতীয়ত সময়। Page program সাধারণত 0.4 ms, sector erase সাধারণত 45 ms, কিন্তু সর্বোচ্চ 400 ms. এই সময় chip BUSY, পড়া যায় না; তাই পরের sector আগেভাগে মুছে রাখা ভালো, আর BUSY-এর অপেক্ষা যেন alarm-এর কাজ থামিয়ে না দেয়।

তৃতীয়ত বিদ্যুৎ চলে যাওয়া, বাংলাদেশে যা খুবই বাস্তব। একটি page program-এর মাঝখানে বিদ্যুৎ গেলে record অর্ধেক লেখা থাকতে পারে; erase-এর মাঝে গেলে sector-এর অবস্থা অনিশ্চিত। তাই প্রতিটি record-এ ক্রমিক নম্বর আর checksum (এই পর্বের মডেলে xor; বাস্তবে CRC ভালো) রাখা হয়। চালু হওয়ার পরে firmware log স্ক্যান করে শেষ বৈধ record খুঁজে বের করে: ক্রমিক নম্বর সবচেয়ে বড় আর checksum মেলে, তার পরের প্রথম পুরো 0xFF জায়গায় লেখা শুরু। কোনো record checksum না মেললে সেটি বাদ যায়, কিন্তু পুরো log নষ্ট হয় না। Record-এর আকার page-এর ভাগফল রাখলে (8 byte, 256-এর ভাগ) কোনো record দুই page-এ ভাগ হয় না, যা অংশ ৫-এর wrap-এর ফাঁদও এড়ায়।

মূল উপলব্ধি: Flash-এ log মানে শুধু SPI-তে byte পাঠানো নয়: ধারণক্ষমতা আর ক্ষয়ের হিসাব, ধীর erase-এর পরিকল্পনা, আর ক্রমিক নম্বর ও checksum দিয়ে বিদ্যুৎ-বিভ্রাটের পরেও নিজেকে খুঁজে পাওয়ার ক্ষমতা।

প্র ০৫SPI-এর clock 50 MHz থেকে 100 MHz-এ তুললে শুধু “দ্বিগুণ গতি” নয়, নকশার আরও কী বদলায়? Quad SPI আর execute-in-place কোন সমস্যার সমাধান?

কম গতিতে SPI-এর তারকে আদর্শ ধরা যায়: master SCK তুলল, slave সঙ্গে সঙ্গে দেখল, বিট সঙ্গে সঙ্গে ফিরল। গতি বাড়লে প্রতিটি “সঙ্গে সঙ্গে”-র দাম দেখা দেয়। MISO-র পথটি দেখুন। Master SCK-এর নামতি ধার দেয়; সেটি PCB-র trace ধরে slave-এ পৌঁছায়; slave নতুন বিট বের করে, যার জন্য W25Q128JV-এর datasheet-এ “Clock Low to Output Valid” সর্বোচ্চ 6 ns; বিটটি আবার trace ধরে ফেরে; আর master-এর input-এর নিজের setup time আছে। এই সবকিছু আধা period-এর মধ্যে শেষ হওয়া চাই, কারণ master পরের উঠতি ধারে পড়ে। 50 MHz-এ আধা period 10 ns, 100 MHz-এ মাত্র 5 ns, যা slave-এর 6 ns-এরও কম। তাই উচ্চ গতির SPI controller-গুলোতে প্রায়ই পড়ার মুহূর্ত পিছিয়ে দেওয়ার সুবিধা (sample delay) থাকে, নির্দিষ্ট chip-এর manual দেখে নিতে হয়।

দ্বিতীয় বদল সংকেতের মান। দ্রুত ধার মানে লম্বা trace আর তার antenna-র মতো আচরণ করে: প্রতিফলন, পাশের তারে crosstalk, আর ধারে বাড়তি ঢেউ, যা একটি clock ধারকে দুটি দেখাতে পারে; SPI-তে বাড়তি একটি SCK ধার মানে পুরো byte এক ঘর সরে যাওয়া।

এ কারণে clock বাড়ানোর বদলে তার বাড়ানো হলো। Dual আর Quad SPI-তে MOSI আর MISO দুই দিকের তার হয়ে যায়, আর দুটি বাড়তি তার যোগ হয়, ফলে প্রতি clock-এ চার বিট। একই 50 MHz-এ চার গুণ data. W25Q128JV-এর মতো flash এই command-গুলো সমর্থন করে। এর সবচেয়ে বড় ফল execute in place: অনেক microcontroller বাইরের Quad SPI flash-কে নিজের memory map-এ বসায়, CPU সেখান থেকে সরাসরি নির্দেশ পড়ে, সাধারণত একটি cache-এর সাহায্যে। ফলে ছোট on-chip flash-এর chip-ও বড় firmware চালাতে পারে; Raspberry Pi-র RP2040-এর মতো কিছু chip-এ কোনো on-chip flash-ই নেই, program থাকে বাইরের QSPI flash-এ (নির্দিষ্ট chip-এর datasheet দেখে নিন)। দাম: flash থেকে প্রথম নির্দেশ পেতে অনেকগুলো clock, তাই cache miss-এ CPU থেমে থাকে, আর সময়-সংবেদনশীল ISR প্রায়ই on-chip RAM-এ রাখা হয়।

মূল উপলব্ধি: উচ্চ গতির SPI-তে আধা period-এর মধ্যে পুরো round-trip, সংকেতের মান আর শক্তি সীমা টানে; তাই শিল্প clock-এর বদলে data তার বাড়িয়েছে, আর Quad SPI বাইরের flash-কে সরাসরি program memory বানিয়েছে।

অনুশীলন

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

  1. নকশা ও বাস্তবায়ন — page-এর সীমা মেনে লেখা: বাজারঘরের নতুন log-এ প্রতিটি record 12 byte (তাপমাত্রার সঙ্গে আর্দ্রতাও)। Record k বসে ঠিকানা 12 × k-তে। একটি flash_write(uint32_t addr, const uint8_t *buf, uint32_t len) লিখুন, যা W25Q128JV-ধাঁচের flash-এ নিরাপদে লেখে। আপনার কাছে আছে spi_xfer(uint8_t), cs_low(), cs_high(). কোন record প্রথম একটি page-এর সীমা পেরোয়, আর সরাসরি একবারে লিখলে কী নষ্ট হতো?

    12 × 21 = 252 = 0xFC: record 21-এর মাত্র ৪টি byte page 0-তে ধরে, বাকি ৮টি পরের page-এ যাওয়ার কথা। একবারে লিখলে সেই ৮টি byte page 0-এর শুরুতে ঘুরে record 0-কে নষ্ট করত। আমার lab-এ অংশ ৫-এর flash মডেলে ৩০টি record লিখে দেখা: সরাসরি লেখায় naive bad records: [0, 21], ভাগ করে লেখায় split bad records: [].

    static void flash_wait_ready(void)
    {
        cs_low(); (void)spi_xfer(0x05u);                 /* Read Status-1 */
        while (spi_xfer(0x00u) & 0x01u) { }              /* BUSY = 1 হলে অপেক্ষা */
        cs_high();
    }
    
    void flash_write(uint32_t addr, const uint8_t *buf, uint32_t len)
    {
        while (len > 0u) {
            uint32_t room  = 256u - (addr & 0xFFu);        /* এই page-এ বাকি জায়গা */
            uint32_t chunk = (len < room) ? len : room;
            cs_low(); (void)spi_xfer(0x06u); cs_high();    /* WREN: আলাদা লেনদেন */
            cs_low();
            (void)spi_xfer(0x02u);
            (void)spi_xfer((uint8_t)(addr >> 16));
            (void)spi_xfer((uint8_t)(addr >> 8));
            (void)spi_xfer((uint8_t)addr);
            for (uint32_t i = 0u; i < chunk; i++) (void)spi_xfer(buf[i]);
            cs_high();                                     /* এখনই লেখা শুরু */
            flash_wait_ready();
            addr += chunk; buf += chunk; len -= chunk;
        }
    }

    এটি উদাহরণ, hardware-এ চালানো নয়; যুক্তিটি Python-এ একই flash মডেলে যাচাই করা। Status পড়ার সময় CS নামিয়ে রেখে বারবার byte পড়া চলে, কারণ datasheet অনুযায়ী status register পরপর বের হতে থাকে। আসল firmware-এ এই অপেক্ষায় একটি সময়সীমাও রাখুন (sector erase সর্বোচ্চ 400 ms), যাতে chip না থাকলে বা নষ্ট হলে firmware চিরকাল আটকে না থাকে।

  2. ভুল খুঁজুন — bit-banged mode 0: একজন একটি mode 0 flash-এর জন্য এই কোড লিখলেন (MOSI অলস অবস্থায় 1): cs_low(); for (i = 7; i >= 0; i--) { sck(1); mosi((b >> i) & 1); in = (in << 1) | miso(); sck(0); } তারপর 06h পাঠিয়ে CS না তুলেই 02h, ঠিকানা আর data পাঠালেন, শেষে cs_high(). কিছুই লেখা হয় না। দুটি ভুল খুঁজুন, আর বলুন 0x9F পাঠালে flash কোন byte পায়।

    ১. ধারের ভুল: MOSI বদলানো হচ্ছে SCK তোলার পরে, অর্থাৎ উঠতি ধারে, ঠিক যখন mode 0-এর flash পড়ে। এটি আসলে mode 1-এর master আর mode 0-এর slave-এর জোড়া: প্রথম পড়ায় flash পায় অলস 1, তারপর b7 থেকে b1, আর b0 হারায়। অংশ ৩-এর মডেলের সারণিতে ঠিক এই ঘর: 0x9F → 0xCF, hold margin শূন্য। সঠিক ক্রম: SCK নিচে থাকতে MOSI বসানো, তারপর SCK তোলা আর MISO পড়া, তারপর SCK নামানো (অংশ ৭-এর কোড)। ২. CS-এর ভুল: Write Enable একটি পুরো লেনদেন: CS নামিয়ে 06h, তারপর CS তোলা; datasheet অনুযায়ী তখনই WEL 1 হয়। CS না তুলে 02h পাঠালে flash সেটিকে 06h-এর পরের বাড়তি byte ভাবে, আর আলাদা page program command কখনো শুরুই হয় না। তার ওপর প্রথম ভুলের কারণে 06h নিজেই ভুল byte হয়ে পৌঁছায়। দুটিই কোনো error ছাড়া চুপচাপ ব্যর্থ হয়, তাই লেখার পরে 03h দিয়ে পড়ে মিলিয়ে দেখা জরুরি।

  3. হিসাব — গতি আর ধারণক্ষমতা: STM32F103-এর SPI1 APB2-তে 72 MHz. (ক) BR = 010 হলে SCK কত, আর W25Q128JV-এর 03h দিয়ে ঠিকানা থেকে 256 byte পড়তে কত সময় (command আর ঠিকানাসহ)? (খ) BR = 001 হলে একই কাজ? (গ) Cold room প্রতি 1 s-এ একটি 8 byte-এর record লিখলে 16 MiB flash কত দিনে ভরবে, আর প্রতি 10 s-এ লিখলে?

    (ক) BR = 010 মানে fPCLK ÷ 8 = 9 MHz. বিট = (1 + 3 + 256) × 8 = 2080; সময় = 2080 ÷ 9 MHz ≈ 231.11 µs. (খ) BR = 001 মানে ÷ 4 = 18 MHz, chip-এর সীমার ভেতরে (03h-এ সর্বোচ্চ 50 MHz); সময় ≈ 115.56 µs. বাস্তবে byte-এর মাঝের ফাঁক আর CS-এর সময় যোগ হয়, তাই আসল সময় একটু বেশি। (গ) 1 s-এ: দিনে 86400 × 8 = 691200 byte, 16777216 ÷ 691200 ≈ 24.27 দিন। 10 s-এ: দিনে 69120 byte, ≈ 242.73 দিন। সব মান Python-এ চালিয়ে মেলানো: 231.11 us, 115.56 us, 24.27, 242.73.

  4. আগে বলুন, তারপর মেলান — অদলবদল আর শিকল: (ক) Mode 0-এ master-এর register-এ 0x03, slave-এর register-এ 0xA5. চারটি clock-এর পরে দুই register-এ কী থাকবে? আটটির পরে? (খ) তিনটি 8-বিট shift register-এর daisy chain-এ যন্ত্র A (MOSI-র পাশে), B, C (MISO-র পাশে)। C-তে 0x01, B-তে 0x02, A-তে 0x03 বসাতে কোন ক্রমে byte পাঠাবেন আর কতটি clock?

    (ক) চার clock-এ প্রতিটি register চার ঘর বাঁয়ে সরে, আর ডানে অন্যজনের প্রথম চার বিট ঢোকে: master = 0011 (0x03-এর নিচের চার বিট) + 1010 (0xA5-এর ওপরের চার বিট) = 0x3A; slave = 0101 + 0000 = 0x50. আট clock-এ পুরো অদলবদল: master 0xA5, slave 0x03. মানগুলো অংশ ২-এর exchange function-এ চালিয়ে মেলানো। (খ) প্রথমে পাঠানো byte যায় সবচেয়ে দূরে, তাই ক্রম 0x01 (C-র জন্য), 0x02 (B), 0x03 (A); মোট 24টি clock, তারপর CS তুলে latch. অংশ ৪-এর মডেলে দুই যন্ত্রে একই নিয়ম দেখা গেছে: 0xA1 আগে পাঠিয়ে সেটি dev1-এ।

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

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

ক্রমএকটি আগে মোছা SPI flash-এর page-এ লেখার ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. CS নামিয়ে Write Enable (06h) পাঠানো, তারপর CS তোলা
  2. CS নামিয়ে Page Program (02h), 24-বিট ঠিকানা আর data পাঠানো
  3. শেষ byte-এর অষ্টম বিটের পরে CS তোলা, তখন chip লেখা শুরু করে
  4. Read Status (05h) দিয়ে BUSY 0 হওয়া পর্যন্ত অপেক্ষা
  5. Read Data (03h) দিয়ে পড়ে লেখা data-র সঙ্গে মিলিয়ে দেখা

একটি SPI slave-এর datasheet বলে, তার mode 3 (CPOL = 1, CPHA = 1). এর অর্থ কী?

  • অলস SCK নিচে, প্রথম (উঠতি) ধারে পড়া
  • অলস SCK উঁচু, প্রথম (নামতি) ধারে পড়া
  • অলস SCK উঁচু, দ্বিতীয় (উঠতি) ধারে পড়া
  • অলস SCK নিচে, দ্বিতীয় (নামতি) ধারে পড়া

SPI-তে master একটি slave থেকে 1 byte পড়তে চায়, কিছু লিখতে চায় না। কী করতে হবে?

  • শুধু অপেক্ষা করা, slave নিজেই clock দিয়ে byte পাঠাবে
  • একটি dummy byte পাঠানো; একই আট clock-এ slave-এর byte ফিরে আসে
  • Slave-এর 7-বিট ঠিকানা আর একটি read বিট পাঠানো
  • MOSI-কে input বানিয়ে half duplex-এ পড়া

STM32F103-এর SPI1 চলে 72 MHz-এর APB2 clock-এ। SPI_CR1-এর BR[2:0] = 010 হলে SCK কত?

  • 9 MHz
  • 18 MHz
  • 36 MHz
  • 4.5 MHz

তিনটি 8-বিট shift register (যেমন 74HC595) daisy chain-এ, একটি CS-এর নিচে। তিনটির মান একবারে বদলাতে কয়টি SCK clock লাগে, আর প্রথমে পাঠানো byte কোথায় পৌঁছায়?

  • 8 clock, প্রথম register-এ
  • 16 clock, শেষ register-এ
  • 24 clock, MOSI-র পাশের register-এ
  • 24 clock, MISO-র পাশের (সবচেয়ে দূরের) register-এ

একটি SPI flash-এর page 256 byte, আর page program-এ data page-এর শেষ পেরোলে ঠিকানা সেই page-এর শুরুতে ঘোরে। আগে মোছা chip-এ ঠিকানা 0x0000F8 থেকে 16 byte লেখা হলো। শেষ 8 byte কোথায় যায়?

  • 0x000100 থেকে 0x000107-এ
  • 0x000000 থেকে 0x000007-এ
  • কোথাও না, chip সেগুলো ফেলে দেয়
  • পুরো command বাতিল হয়, কিছুই লেখা হয় না

একটি bit-banged SPI master SCK তোলার ঠিক পরে MOSI-তে নতুন বিট বসায় (MOSI অলস অবস্থায় 1). Slave mode 0-এ, অর্থাৎ উঠতি ধারে পড়ে। Master 0x9F পাঠালে slave কী পায়?

  • 0x9F, কোনো সমস্যা ছাড়া
  • 0xF9
  • 0xCF
  • 0x00

শব্দকোষ

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

মনে রাখুন

  1. চার তার: SCK, MOSI আর CS master চালায়, MISO নির্বাচিত slave; ঠিকানা আর ACK নেই, CS নামা থেকে ওঠা পর্যন্ত একটি লেনদেন।
  2. Full duplex: দুটি shift register-এর বৃত্ত; আট clock-এ দুই byte অদলবদল, পড়তে dummy byte পাঠাতে হয়।
  3. Mode = 2 × CPOL + CPHA: CPOL অলস SCK, CPHA পড়ার ধার; mode 0 আর 3 উঠতিতে পড়ে, 1 আর 2 নামতিতে; ভুল mode-এ এক ঘর সরে যাওয়া byte বা শূন্য margin.
  4. কয়েকটি slave: প্রতিটির আলাদা CS, এক মুহূর্তে একটি; daisy chain-এ একটি CS, সব বিট একসাথে, প্রথম byte যায় সবচেয়ে দূরে।
  5. SPI flash আর board: 9Fh-এ ID, প্রতিটি লেখার আগে 06h, page-এর ভেতরে ঘোরা, BUSY-এর অপেক্ষা, লেখার পরে পড়ে মেলানো; board-এর bit-banged run-এ অসম SCK-ও ঠিক কাজ করে, কারণ clock ডেটার সঙ্গেই যায়।

পরের পর্বে: পর্ব ৫১ (I2C). দুটি open-drain তারে অনেক যন্ত্র: ঠিকানা, ACK আর NACK, start আর stop, clock stretching, আর virtual board-এ cold room-এর তাপমাত্রার sensor-এর আসল পড়া।

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

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