SPI প্রোটোকল

১ · SPI কেন "সিঙ্ক্রোনাস"

আগের পাঠে UART দেখা গেছে, যেখানে দুই পাশ শুধু একটি বড রেট নিয়ে "একমত" থাকে, কোনো ভাগাভাগি করা ক্লক তার নেই। SPISPISerial Peripheral Interface -- একটি সিঙ্ক্রোনাস, ফুল-ডুপ্লেক্স সিরিয়াল প্রোটোকল যেখানে মাস্টার নিজেই ক্লক লাইন চালায়। এর বিপরীত -- এখানে মাস্টার নিজেই একটি ক্লক লাইন (SCLK) চালায়, আর স্লেভ প্রতিটি ক্লক পালসে ঠিক এক বিট করে ডেটা শিফট করে। যেহেতু ক্লক ভাগাভাগি করা হয়, বড রেট অনুমান করার কোনো প্রশ্নই ওঠে না -- উভয় পাশ ঠিক একই ক্লক এজ-এ কাজ করে।

SPI-তে চারটি সিগন্যাল লাগে:

• MOSI (Master Out, Slave In) -- মাস্টার থেকে স্লেভে ডেটা
• MISO (Master In, Slave Out) -- স্লেভ থেকে মাস্টারে ডেটা
• SCLK (Serial Clock) -- মাস্টার এই ক্লক চালায়, প্রতিটি পালসে ১ বিট শিফট হয়
• CS/SS (Chip Select / Slave Select) -- মাস্টার কোন স্লেভের সাথে কথা বলছে তা নির্বাচন করে (একাধিক স্লেভ থাকলে প্রতিটির জন্য আলাদা CS লাইন লাগে)

২ · শিফট-রেজিস্টার মডেল -- কেন এটি কাজ করে

SPI-এর আসল কৌশলটা বোঝা সহজ যদি মাস্টার ও স্লেভের ৮-বিট রেজিস্টারকে একটি একক ১৬-বিট সার্কুলার রেজিস্টার হিসেবে কল্পনা করা যায় -- মাস্টারের ৮ বিট উপরে, স্লেভের ৮ বিট নিচে। প্রতিটি ক্লক পালসে:

• মাস্টারের সবচেয়ে গুরুত্বপূর্ণ বিট (MSB) MOSI দিয়ে বেরিয়ে স্লেভের সবচেয়ে কম গুরুত্বপূর্ণ বিটের জায়গায় ঢোকে
• স্লেভের MSB MISO দিয়ে বেরিয়ে মাস্টারের সবচেয়ে কম গুরুত্বপূর্ণ বিটের জায়গায় ঢোকে

এটি ঠিক এই ১৬-বিট রেজিস্টারকে ১ বিট বাম দিকে সার্কুলার শিফট করার সমান। তাই ৮ বার শিফট করলে (৮টি ক্লক পালস) পুরো ১৬-বিট রেজিস্টার ঠিক অর্ধেক (৮ বিট) ঘুরে যায় -- যা মাস্টারের আসল ৮ বিট আর স্লেভের আসল ৮ বিটকে সম্পূর্ণভাবে অদল-বদল করে দেয়। এটাই নিচের কোড সেল সত্যিই চালিয়ে যাচাই করে দেখাচ্ছে।

def to_bin(v):
    return format(v, '08b')


def spi_transfer(master_reg, slave_reg, num_bits=8):
    print(f"শুরুতে       : master_reg={to_bin(master_reg)} (0x{master_reg:02X})  "
          f"slave_reg={to_bin(slave_reg)} (0x{slave_reg:02X})")
    for pulse in range(1, num_bits + 1):
        master_out = (master_reg >> 7) & 1   # MOSI দিয়ে মাস্টারের MSB বের হচ্ছে
        slave_out = (slave_reg >> 7) & 1      # MISO দিয়ে স্লেভের MSB বের হচ্ছে
        master_reg = ((master_reg << 1) | slave_out) & 0xFF
        slave_reg = ((slave_reg << 1) | master_out) & 0xFF
        print(f"ক্লক পালস {pulse}  : MOSI={master_out} MISO={slave_out}  ->  "
              f"master_reg={to_bin(master_reg)}  slave_reg={to_bin(slave_reg)}")
    return master_reg, slave_reg


original_master = 0xA5   # 1010 0101 -- মাস্টার যা পাঠাতে চায় (যেমন একটি কমান্ড বাইট)
original_slave = 0x3C    # 0011 1100 -- স্লেভ যা পাঠাতে চায় (যেমন একটি সেন্সর রিডিং)

print("=== SPI ফুল-ডুপ্লেক্স শিফট-রেজিস্টার এক্সচেঞ্জ (৮ ক্লক পালস) ===\n")
final_master, final_slave = spi_transfer(original_master, original_slave)

print(f"\n৮ পালসের পর  : master_reg={to_bin(final_master)} (0x{final_master:02X})  "
      f"slave_reg={to_bin(final_slave)} (0x{final_slave:02X})")

assert final_master == original_slave, "এক্সচেঞ্জ ব্যর্থ -- মাস্টার স্লেভের আসল মান পায়নি!"
assert final_slave == original_master, "এক্সচেঞ্জ ব্যর্থ -- স্লেভ মাস্টারের আসল মান পায়নি!"
print("\nযাচাই সফল: মাস্টারের রেজিস্টারে এখন স্লেভের আসল মান (0x3C), "
      "আর স্লেভের রেজিস্টারে এখন মাস্টারের আসল মান (0xA5) -- ফুল-ডুপ্লেক্স এক্সচেঞ্জ সম্পন্ন।")

৩ · SPI-এর গতি -- কেন এটি UART-এর চেয়ে দ্রুত

যেহেতু SPI-তে মাস্টার নিজেই ক্লক চালায় (কোনো বড রেট-ম্যাচিং লাগে না), এটি সাধারণত UART-এর চেয়ে অনেক বেশি ক্লক ফ্রিকোয়েন্সিতে চালানো যায়। একটি নির্দিষ্ট ক্লক ফ্রিকোয়েন্সিতে ৮ বিট (১ বাইট) পাঠাতে কত সময় লাগে তা সরাসরি গণনাযোগ্য:

$$transfer\_time_{\mu s} = \frac{num\_bits}{f_{clock}} \times 10^6$$

def spi_byte_transfer_time_us(clock_hz, num_bits=8):
    return (num_bits / clock_hz) * 1e6


for clock_hz in [1_000_000, 10_000_000, 50_000_000]:
    t_us = spi_byte_transfer_time_us(clock_hz)
    print(f"SCLK = {clock_hz:>11,} Hz  ->  ১ বাইট (৮ বিট) পাঠাতে সময় = {t_us:.4f} µs")