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

UART — baud rate, frame, parity আর ring buffer

UART — Baud Rate, Frame, Parity and Ring Buffer

Taught in Bangla, this lesson builds a UART frame bit by bit (start, LSB-first data, parity, stop), computes STM32F1-style BRR values and baud error (0x271 at 72 MHz; 69 and +0.64% at 8 MHz), and models how a 6% baud mismatch turns 'T' into 0xD4 with no error flag. On the course's virtual BG-M3 board an RXNE interrupt feeds a ring buffer: a 13-byte burst into 8 slots drops 5 bytes, while a 16-slot buffer keeps up. XOR-checksummed commands, flow control and TTL versus RS-232 levels follow.

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

  • একটি UART frame বিট ধরে আঁকা আর পড়া: start, data (LSB আগে), parity, stop; 8N1 আর 8E1-এর খরচ
  • যেকোনো clock আর baud-এর জন্য BRR আর ভুলের শতাংশ হিসাব করা, আর কতটা ভুল চলে তা যুক্তি দিয়ে বলা
  • গ্রাহক কীভাবে oversampling দিয়ে বিট পড়ে, আর framing, parity, noise ও overrun error কেন হয়
  • RXNE interrupt থেকে ring buffer হয়ে main-এ কমান্ড পৌঁছানো, buffer-এর মাপ ঠিক করা আর হারানো byte সামলানো
  • TTL, RS-232 আর USB-UART-এর পার্থক্য, flow control আর নিরাপদে তার জোড়ার নিয়ম

১ · UART কী — দুই তার, কোনো clock নেই

UART (universal asynchronous receiver-transmitter) একটি microcontroller-এর সবচেয়ে পুরোনো আর সবচেয়ে বেশি ব্যবহৃত serial peripheral. তার লাগে মাত্র তিনটি: TX (পাঠানো), RX (নেওয়া) আর GND (দুই পক্ষের সাধারণ ভিত্তি). এক পক্ষের TX যায় অন্য পক্ষের RX-এ, তাই দুই দিকে একসাথে কথা চলে: এটি full-duplex. Firmware-এর debug বার্তা, GPS module, Bluetooth বা Wi-Fi module-এর AT কমান্ড, আর বাজারঘরের smart scale-এর দামের লাইন, সবই সাধারণত UART-এ যায়।

কোর্সে UART-এর দুটি রূপ আপনি আগেই দেখেছেন। পর্ব ১৩-এ 8085-এর SOD pin দিয়ে software-এ বিট বানানো, অর্থাৎ bit-banging; আর পর্ব ২৭-এ Intel-এর 8251A USART chip, তার mode word, ×16 clock আর ‘9’ অক্ষরের frame. এই পর্ব সেখান থেকে এগোয়: আজকের microcontroller-এর ভেতরের UART, তার register, baud-এর ভুলের হিসাব, interrupt আর buffer দিয়ে নির্ভরযোগ্য firmware. সাধারণ bus আর I/O-র তত্ত্ব আছে Computer Architecture পর্ব ৫১-এ। এই পর্বে hex লেখা হবে C-ধাঁচে, 0x….

উপমা — স্কুলের ঘণ্টা আর মুখস্থ তাল: দুই বন্ধু ঠিক করল, প্রতি সেকেন্ডে একটি করে হাততালি দিয়ে বার্তা পাঠাবে: তালি মানে 1, চুপ মানে 0. কিন্তু কারও হাতে ঘড়ি নেই। তাই নিয়ম: চুপচাপ বসে থাকার সময় হাত উঁচু (লাইন 1); বার্তা শুরুর সংকেত হাত নামানো (start বিট 0), যা দেখেই গ্রাহক মনে মনে গোনা শুরু করে, “এক, দুই, তিন…”, আর প্রতিটি সেকেন্ডের ঠিক মাঝখানে তাকিয়ে দেখে। আটটি গোনার পরে প্রেরক আবার হাত তোলে (stop বিট 1), যাতে পরের বার্তার শুরু চেনা যায়। দুজনের মনে মনে গোনার তাল একটু আলাদা হলেও দশ গোনা পর্যন্ত মিল থাকে; অনেক আলাদা হলে শেষের দিকে গ্রাহক ভুল জায়গায় তাকায়। UART ঠিক এভাবেই চলে, আর এই পর্বের অর্ধেক কথা সেই “তালের মিল” নিয়ে।

এর নাম তাই asynchronous: আলাদা clock-এর তার নেই, প্রতিটি byte নিজেই নিজের সময় ঠিক করে। পরের পর্বের SPI (পর্ব ৫০) আর I2C (পর্ব ৫১) এর উল্টো: সেখানে একটি clock-এর তার আছে, তাই তাল মেলানোর সমস্যা নেই, বদলে তার বেশি।

২ · একটি frame, বিট ধরে — start, data, parity, stop

কিছু পাঠানোর না থাকলে TX লাইন 1-এ থাকে (idle). প্রতিটি byte একটি frame-এ যায়:

  • Start বিট: সবসময় 0. লাইনের 1 থেকে 0-তে নামা ধারটিই গ্রাহকের “গোনা শুরু” সংকেত।
  • Data বিট: সাধারণত ৮টি (৭ বা ৯-ও হয়), সবচেয়ে ছোট বিট D0 আগে (LSB first).
  • Parity বিট (ঐচ্ছিক): even parity-তে এমনভাবে বসানো যে data আর parity মিলিয়ে 1-এর সংখ্যা জোড় হয়; odd parity-তে বিজোড়।
  • Stop বিট: সবসময় 1, এক বা দুইটি। লাইনকে আবার idle-এ ফেরায়, যাতে পরের start-এর ধার চেনা যায়।

Frame-এর ছোট নাম “data-parity-stop”: 8N1 মানে ৮ data বিট, কোনো parity নেই, ১টি stop (মোট ১০ বিট, আজকের সবচেয়ে প্রচলিত); 8E1 মানে ৮ বিট, even parity, ১ stop (১১ বিট). বাজারঘরের scale-কে দোকানের কম্পিউটার কমান্ড পাঠায় TARE, যার প্রথম অক্ষর 'T' = 0x54 = 0101 0100. 8E1-এ তার frame নিচের ছবিতে:

ছবি ৪৯.১ — 'T' (0x54), 8E1, 115200 baud

প্রতিটি ঘর এক বিট = 8.68 µs; বিন্দু = গ্রাহকের sample, বিটের মাঝখানে

'T' অক্ষরের 8E1 UART frame data, LSB আগে SD0D1D2D3D4D5D6D7PSP 00010101011 10 043.4095.49 µs data-য় তিনটি 1, তাই even parity P = 1 লাইনে পড়ুন বাঁ থেকে: 0 0010 1010 1 1
ছবি ৪৯.১ — বিটের মান আর সময় আমার lab-এর frame.py আর stepcheck.py থেকে। লক্ষ্য করুন, লাইনে D0 আগে যায়, তাই 0x54 = 0101 0100 লাইনে দেখায় উল্টো ক্রমে: 0010 1010.
idle1 1 1 …S0D0-30 0 1 0D4-71 0 1 0P1SP1
ধাপের শেষে
সময় (µs)
লাইনে
পাওয়া data (D7…D0)
1-এর গোনা
RXNE
  1. Idle. কিছু পাঠানোর নেই, TX লাইন 1-এ। গ্রাহক শুধু অপেক্ষা করছে কখন লাইন নামে।
  2. Start বিট, 0 থেকে 8.68 µs. লাইন 0-তে নামল। গ্রাহক এই ধার থেকে গোনা শুরু করে, আর আধা বিট পরে (4.34 µs) আবার দেখে: এখনো 0, তাই এটি আসল start, noise নয়।
  3. D0 থেকে D3. 0x54-এর নিচের nibble 4 = 0100, LSB আগে বলে লাইনে আসে 0, 0, 1, 0. গ্রাহক প্রতিটি বিটের মাঝখানে sample নিয়ে shift register-এ ঢোকায়। এ পর্যন্ত একটি 1.
  4. D4 থেকে D7. ওপরের nibble 5 = 0101, লাইনে 1, 0, 1, 0. ৭৮.১২ µs-এ পুরো byte হাতে: 0101 0100 = 0x54. মোট তিনটি 1.
  5. Parity. Even parity-তে প্রেরক 1 বসিয়েছে, যাতে মোট চারটি 1 হয়। গ্রাহক নিজে গুনে দেখে চারটি, জোড়: parity ঠিক।
  6. Stop, 95.49 µs-এ শেষ. Stop বিট 1, যেমন হওয়ার কথা, তাই framing ঠিক। byte data register-এ গেল আর RXNE = 1; CPU এখন পড়তে পারে। ১১ বিটে ৮ বিটের কাজ।

নিচের Python ব্লক একই frame বানায় আর পড়ে, তারপর ইচ্ছা করে বিট উল্টে দেখে কোন ভুল ধরা পড়ে আর কোনটি পড়ে না। এটি একটি মডেল; আসল UART এই কাজ hardware-এ করে।

# একটি byte-এর UART frame: start, ৮ data বিট (LSB আগে), even parity, stop
def frame(byte, parity=True):
    data = [(byte >> i) & 1 for i in range(8)]   # D0 আগে
    par = [sum(data) % 2] if parity else []       # even: মোট 1 জোড় রাখে
    return [0] + data + par + [1]                 # start 0 … stop 1

def unframe(bits):
    if bits[0] != 0:
        return "start বিট নেই"
    data = bits[1:9]
    byte = sum(b << i for i, b in enumerate(data))
    if len(bits) == 11 and bits[9] != sum(data) % 2:
        return f"parity error (0x{byte:02X})"
    if bits[-1] != 1:
        return f"framing error (0x{byte:02X})"
    return f"ঠিক: 0x{byte:02X} {chr(byte)!r}"

f = frame(ord("T"))
print("T = 0x54 = 0b01010100")
print("8E1 frame:", "".join(map(str, f)), f"({len(f)} বিট)")
print("পড়া     :", unframe(f))
bad = f.copy(); bad[3] ^= 1                      # D2 উল্টে গেল
print("D2 উল্টো :", unframe(bad))
bad2 = f.copy(); bad2[3] ^= 1; bad2[5] ^= 1       # দুটি বিট উল্টে গেল
print("D2,D4 উল্টো:", unframe(bad2))
bad3 = f.copy(); bad3[-1] = 0                    # stop বিটের জায়গায় 0
print("stop = 0  :", unframe(bad3))
for name, par in (("8N1", False), ("8E1", True)):
    n = len(frame(0x54, par))
    print(f"{name}: {n} বিট/byte, কাজের ভাগ {8 / n:.1%},"
          f" 115200 baud-এ {115200 / n:.0f} byte/s, এক byte {n / 115200 * 1e6:.1f} us")

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

T = 0x54 = 0b01010100
8E1 frame: 00010101011 (11 বিট)
পড়া     : ঠিক: 0x54 'T'
D2 উল্টো : parity error (0x50)
D2,D4 উল্টো: ঠিক: 0x40 '@'
stop = 0  : framing error (0x54)
8N1: 10 বিট/byte, কাজের ভাগ 80.0%, 115200 baud-এ 11520 byte/s, এক byte 86.8 us
8E1: 11 বিট/byte, কাজের ভাগ 72.7%, 115200 baud-এ 10473 byte/s, এক byte 95.5 us

একটি বিট উল্টালে parity ধরে ফেলে। কিন্তু দুটি বিট উল্টালে 1-এর সংখ্যা আবার জোড়, তাই গ্রাহক 'T'-এর বদলে '@' পায় আর বলে “ঠিক”: parity-র এই দুর্বলতা মনে রাখুন, অংশ ৬-এ এর সমাধান। Stop-এর জায়গায় 0 মানে framing error. আর খরচ: 8N1-এ ২০% বিট শুধু কাঠামো, 8E1-এ প্রায় ২৭%. 115200 baud মানে ১১৫২০০ বিট/সেকেন্ড, কিন্তু কাজের data সেকেন্ডে ১১,৫২০ byte.

৩ · Baud rate আর BRR — ভাগফল, ভগ্নাংশ আর ভুলের শতাংশ

Baud rate হলো প্রতি সেকেন্ডে কয়টি symbol; UART-এ প্রতি symbol একটি বিট, তাই 115200 baud মানে এক বিট 1 ÷ 115200 s = 8.68 µs. এই সময় আসে peripheral-এর clock ভাগ করে। কোন clock কোন peripheral-এ যায় (STM32F103-এ USART1 থাকে APB2-তে, USART2 আর 3 APB1-এ), সেই clock tree-র কথা পর্ব ৩৩-এ। এখানে ভাগের অঙ্কটি।

STM32F1-এর reference manual (RM0008, USART অধ্যায়) সূত্রটি দেয়: baud = fCK ÷ (16 × USARTDIV), যেখানে ১৬ হলো oversampling (অংশ ৪) আর USARTDIV একটি fixed-point সংখ্যা (পর্ব ৪০): BRR register-এর বিট 15–4-এ পূর্ণ অংশ (DIV_Mantissa), বিট 3–0-এ ষোলো ভাগের কত ভাগ (DIV_Fraction). অর্থাৎ BRR-এ আসলে লেখা হয় 16 × USARTDIV, নিকটতম পূর্ণসংখ্যায়।

উদাহরণ ১, ধাপে ধাপে: fPCLK = 72 MHz, লক্ষ্য 115200 baud.

  1. USARTDIV = 72,000,000 ÷ (16 × 115200) = 39.0625.
  2. পূর্ণ অংশ 39 = 0x27; ভগ্নাংশ 0.0625 × 16 = 1.
  3. BRR = 39 × 16 + 1 = 625 = 0x271.
  4. আসল baud = 72,000,000 ÷ 625 = 115200, ভুল 0%.

উদাহরণ ২: একই baud, কোর্সের board-এর 8 MHz. 8,000,000 ÷ 115200 = 69.44, নিকটতম 69 = 0x45, মানে USARTDIV = 4 + 5/16 = 4.3125. আসল baud = 8,000,000 ÷ 69 = 115942, ভুল +0.64%. Board-এর uart_init() ঠিক এটিই লেখে: BRR = (SystemCoreClock + 115200/2) / 115200, অর্থাৎ ভাগ করে নিকটতমে গোল করা। তবে মনে রাখুন, board BRR শুধু জমা রাখে, baud-এর সময় মাপে না (Spec decision 24), তাই board-এ ভুল baud-এর ফল দেখা যাবে না; সেটি দেখাবে অংশ ৪-এর মডেল।

# STM32F1-ধাঁচের BRR: baud = fck / (16 × USARTDIV), USARTDIV ১২.৪ fixed-point
def brr(fck, baud):
    div16 = round(fck / baud)          # = 16 × USARTDIV, নিকটতম পূর্ণসংখ্যা
    mant, frac = div16 >> 4, div16 & 0xF
    real = fck / div16                 # আসল baud
    err = (real / baud - 1) * 100
    return div16, mant, frac, real, err

print("fck   baud     BRR    USARTDIV        আসল baud   ভুল %")
for fck in (8e6, 36e6, 72e6):
    for baud in (9600, 115200, 460800):
        d, m, fr, real, err = brr(fck, baud)
        print(f"{fck/1e6:3.0f} {baud:7} 0x{d:04X} {m:4} + {fr:2}/16"
              f" {real:12.1f} {err:+6.2f}")

# কোর্সের board-এর uart_init(): BRR = (8000000 + 57600) / 115200
board = (8_000_000 + 115200 // 2) // 115200
print(f"\nboard: BRR = {board} = 0x{board:02X} -> {board >> 4} + {board & 15}/16"
      f" -> {8e6 / board:.0f} baud")
line = "raw=1380 gross=1400 g tare=150 g net=1250 g price=81.88 Tk" + "\r\n"
for baud in (9600, 115200):
    print(f"{baud} baud: বিট {1e6 / baud:.2f} us, frame {10e6 / baud:.1f} us,"
          f" দামের লাইন ({len(line)} byte) {len(line) * 10e3 / baud:.2f} ms")

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

fck   baud     BRR    USARTDIV        আসল baud   ভুল %
  8    9600 0x0341   52 +  1/16       9603.8  +0.04
  8  115200 0x0045    4 +  5/16     115942.0  +0.64
  8  460800 0x0011    1 +  1/16     470588.2  +2.12
 36    9600 0x0EA6  234 +  6/16       9600.0  +0.00
 36  115200 0x0138   19 +  8/16     115384.6  +0.16
 36  460800 0x004E    4 + 14/16     461538.5  +0.16
 72    9600 0x1D4C  468 + 12/16       9600.0  +0.00
 72  115200 0x0271   39 +  1/16     115200.0  +0.00
 72  460800 0x009C    9 + 12/16     461538.5  +0.16

board: BRR = 69 = 0x45 -> 4 + 5/16 -> 115942 baud
9600 baud: বিট 104.17 us, frame 1041.7 us, দামের লাইন (60 byte) 62.50 ms
115200 baud: বিট 8.68 us, frame 86.8 us, দামের লাইন (60 byte) 5.21 ms

নিয়মটি চোখে পড়ার মতো: ভাগফল যত ছোট, গোল করার ভুল (baud rate error) তত বড়। 8 MHz-এ 460800 baud-এর ভাগফল মাত্র 17, তাই ভুল +2.12%, যা অনেক গ্রাহকের জন্য বিপজ্জনক (অংশ ৪). 36 MHz-এ 115200-এর ভাগফল ঠিক 312.5; Python-এর round জোড় দিকে গোল করে 312 (0x138) নেয়, 313 নিলেও ভুল হতো −0.16%. STM32F1-এ USARTDIV অন্তত 1 হতে হয়, তাই 16 গুণ oversampling-এ সর্বোচ্চ baud fPCLK ÷ 16. শেষ লাইন দুটি পরের অংশগুলোর জন্য জমা রাখুন: scale-এর একটি দামের লাইন 115200 baud-এ 5.21 ms, 9600 baud-এ 62.5 ms.

কেন 115200, 9600-এর মতো অদ্ভুত সংখ্যা? এগুলো এসেছে পুরোনো টেলিটাইপ আর modem-এর 300, 1200, 2400 … থেকে দ্বিগুণ হয়ে, আর PC-র 8250-গোত্রের UART-এর 1.8432 MHz crystal থেকে: 1,843,200 ÷ 16 = 115200, তাই ভাগফল 1 দিলে 115200, 12 দিলে 9600, ভুল শূন্য। একই কারণে 8051-এর বোর্ডে 11.0592 MHz আর AVR-এর বোর্ডে 7.3728 MHz-এর মতো “অদ্ভুত” crystal দেখা যায়: এরা প্রচলিত baud-এর পূর্ণ গুণিতক। আজকের fractional BRR থাকায় 72 MHz-এর মতো গোল clock-এও ভুল প্রায় শূন্য রাখা যায়।

৪ · গ্রাহক কীভাবে পড়ে — oversampling, baud-এর ভুল আর error flag

গ্রাহকের হাতে প্রেরকের clock নেই, আছে শুধু start-এর ধার। তাই সে নিজের clock-কে baud-এর ১৬ গুণে চালায়, একে বলে oversampling. প্রতি বিট ১৬টি ছোট ভাগে ভাগ হয়। লাইন নামার পরে গ্রাহক ধার চেনে ১/১৬ বিটের মধ্যে, আর প্রতিটি বিটের মাঝখানের কাছে (STM32-এ ১৬ ভাগের ৮, ৯ আর ১০ নম্বর ভাগে) তিনটি নমুনা নিয়ে সংখ্যাগরিষ্ঠটি মানে। তিনটি না মিললে noise-এর সন্দেহ: STM32-এ NE (noise error) বিট। পর্ব ২৭-এর 8251A-এর ×16 mode আর false start detection একই নীতির পুরোনো রূপ।

এখন তালের মিল। গ্রাহক ধরে নেয় প্রতিটি বিট তার নিজের হিসাবের সমান লম্বা। প্রেরক যদি একটু দ্রুত হয়, প্রতিটি sample বিটের মাঝখান থেকে একটু একটু করে ডানে সরে। ১০ বিটের frame-এ শেষ sample (stop) নেওয়া হয় start-এর ধার থেকে ৯.৫ বিট পরে; সেখানে সরে যাওয়া আধা বিট ছাড়ালে sample পাশের বিটে পড়ে। তাই আদর্শ সীমা মোটামুটি 0.5 ÷ 9.5 ≈ ৫.২৬%, আর এর মধ্যে ধার চেনার ১/১৬ বিটের অনিশ্চয়তা, লাইনের ধারের ঢাল আর noise-এর জায়গাও রাখতে হয়। STM32-এর কয়েকটি reference manual “receiver tolerance” টেবিলে ৮ data বিট, ১৬ গুণ oversampling আর ভগ্নাংশ 0-র জন্য প্রায় 3.75% দেয় (ভগ্নাংশ থাকলে একটু কম); এটি দুই প্রান্তের মোট ভুলের বাজেট, আর ব্যবহারের আগে নিজের chip-এর manual দেখে নেওয়াই নিয়ম।

সীমা পেরোলে কী হয়? নিচের মডেল 'T'-কে 8N1-এ পাঠায় আর গ্রাহক নিজের তালে পড়ে। “ভুল +6%” মানে প্রেরকের baud গ্রাহকের চেয়ে ৬% বেশি:

# Baud না মিললে গ্রাহক কোন বিট পড়ে: প্রেরক 'T' (8N1) পাঠায় তার নিজের তালে,
# গ্রাহক start-এর নামা ধারের পরে নিজের তালে প্রতিটি বিটের মাঝখানে sample নেয়
def tx_bits(byte):
    return [0] + [(byte >> i) & 1 for i in range(8)] + [1]   # 8N1, ১০ বিট

def receive(byte, err, idle_after=1):
    bits = tx_bits(byte) + [idle_after] * 3       # frame-এর পরে লাইন উঁচু
    t_tx = 1.0 / (1 + err)                        # প্রেরকের এক বিট (গ্রাহকের এককে)
    out, where = [], []
    for k in range(10):
        t = k + 0.5                               # গ্রাহকের k-তম বিটের মাঝখান
        i = int(t / t_tx)                         # তখন তারে প্রেরকের কোন বিট
        out.append(bits[i]); where.append(i)
    data = sum(b << n for n, b in enumerate(out[1:9]))
    status = "ঠিক" if out == tx_bits(byte) else (
        "framing error" if out[9] == 0 else "ভুল byte, error নেই!")
    return out, where, data, status

for err in (0.0, 0.02, 0.04, 0.06, -0.06):
    out, where, data, st = receive(0x54, err)
    print(f"ভুল {err:+.0%}: sample-এ প্রেরকের বিট {where}")
    print(f"          পড়া {''.join(map(str, out))} -> 0x{data:02X} {st}")
lim = 0.5 / 9.5
print(f"আদর্শ সীমা (শেষ sample-এ আধা বিট সরে যাওয়া): ±{lim:.2%}")

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

ভুল +0%: sample-এ প্রেরকের বিট [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
          পড়া 0001010101 -> 0x54 ঠিক
ভুল +2%: sample-এ প্রেরকের বিট [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
          পড়া 0001010101 -> 0x54 ঠিক
ভুল +4%: sample-এ প্রেরকের বিট [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
          পড়া 0001010101 -> 0x54 ঠিক
ভুল +6%: sample-এ প্রেরকের বিট [0, 1, 2, 3, 4, 5, 6, 7, 9, 10]
          পড়া 0001010111 -> 0xD4 ভুল byte, error নেই!
ভুল -6%: sample-এ প্রেরকের বিট [0, 1, 2, 3, 4, 5, 6, 7, 7, 8]
          পড়া 0001010110 -> 0xD4 framing error
আদর্শ সীমা (শেষ sample-এ আধা বিট সরে যাওয়া): ±5.26%

৪% পর্যন্ত এই আদর্শ মডেলে সব ঠিক (মডেলে noise বা ধার চেনার অনিশ্চয়তা নেই, তাই আসল সীমা কম)। ৬%-এ দুই দিকেই ভুল byte, কিন্তু চেহারা আলাদা: প্রেরক ধীর হলে stop-এর sample D7-এর 0-তে পড়ে, framing error ধরা পড়ে; প্রেরক দ্রুত হলে stop-এর sample idle লাইনের 1-এ পড়ে, আর 0xD4 নীরবে গৃহীত হয়। নিচের stepper দ্বিতীয়টি ধাপে ধাপে দেখায়।

k0startk1-4D0–D3k5-7D4–D6k8D7k9stop−6%উল্টো দিক
sample-এর অবস্থান
প্রেরকের এককে
মাঝখান থেকে সরে
পড়া বিট
ফল
  1. Start-এর মাঝখান। গ্রাহক ধার থেকে আধা বিট পরে দেখে। প্রেরক ৬% দ্রুত বলে এই মুহূর্ত প্রেরকের হিসাবে 0.53 বিট: মাঝখান থেকে মাত্র 0.03 সরে। Start ঠিক।
  2. D0 থেকে D3. প্রতি বিটে আরও 0.06 করে সরে: 1.59, 2.65, 3.71, 4.77. সবই নিজের বিটের ভেতরে, পড়া 0 0 1 0 ঠিক।
  3. D4 থেকে D6. 5.83, 6.89, 7.95. শেষটি বিট ৭-এর মাঝখান থেকে 0.45 সরে, ধারের একদম কাছে, তবু ভেতরে। পড়া 1 0 1 ঠিক।
  4. D7 পাশের বিটে। গ্রাহকের ৮.৫ বিট = প্রেরকের 9.01 বিট: sample পড়েছে প্রেরকের stop বিটে (1), অথচ D7 আসলে 0. প্রথম ভুল বিট।
  5. Stop-এর জায়গায় idle. 10.07: frame শেষ, লাইন idle-এ 1. গ্রাহকের চোখে stop ঠিক, তাই কোনো framing error নেই। ফল 0xD4, 'T' নয়, আর firmware কিছুই জানে না। Parity থাকলে এখানে ধরা পড়ত, কারণ 1-এর সংখ্যা এক বেড়েছে।
  6. উল্টো দিক, প্রেরক ৬% ধীর। Sample বাঁয়ে সরে: D7-এর sample 7.99 পড়ে D6-এর 1-এ, stop-এর sample 8.93 পড়ে D7-এর 0-তে। Stop = 0, তাই framing error. একই মাপের ভুল, কিন্তু এক দিকে ধরা পড়ে, অন্য দিকে পড়ে না।

STM32-ধাঁচের UART-এর status register-এ (SR) গ্রাহকের চারটি error flag আছে। কোর্সের board-এর SR-এ শুধু RXNE (বিট ৫), TC (৬) আর TXE (৭), কারণ board-এর লাইন নিখুঁত (Spec decision 24). আসল chip-এর পুরো তালিকা, RM0008-এর বিট-ক্রমে:

Flag (SR বিট)কখন ওঠেসাধারণ কারণFirmware কী করে
PE (0) parity errorগোনা 1-এর সংখ্যা parity-র নিয়ম মানে নাnoise, বা দুই পক্ষের parity-র সেটিং আলাদাbyte ফেলে দেওয়া, ভুল গোনা
FE (1) framing errorstop-এর জায়গায় 0baud না মেলা, তার খোলা, অন্য পক্ষ “break” পাঠাচ্ছেbyte ফেলা; বারবার হলে baud আর তার দেখা
NE (2) noise errorবিটের মাঝের তিন নমুনা মেলেনিলম্বা তার, মোটরের কাছে noiseসতর্ক থাকা; byte সাধারণত তবু ঠিক
ORE (3) overrunআগের byte পড়ার আগেই নতুন byte পুরো এসে গেছেISR দেরিতে, interrupt অনেকক্ষণ বন্ধbyte হারিয়েছে; latency কমানো, DMA

এই flag মোছার নিয়ম chip-এর পরিবার অনুযায়ী আলাদা, আর এটি একটি পরিচিত ফাঁদ। STM32F1-এ (RM0008) SR পড়ার পরে DR পড়লে এই error বিটগুলো মোছে। নতুন অনেক STM32 পরিবারে আলাদা ISR আর ICR register আছে, আর error মুছতে ICR-এ লিখতে হয়; সেখানে ORE না মুছলে RXNEIE-এর interrupt বারবার ফিরে আসতে পারে, যা একটি ISR-এর ঝড়। তাই ISR-এ status একবার পড়ে error বিটও দেখা, নিজের chip-এর নিয়মে মোছা, তারপর data পড়া ভালো অভ্যাস।

৫ · RX-এর পথ — RXNE interrupt, ring buffer আর board-এ burst

STM32F1-এর মতো অনেক microcontroller-এর UART-এ গ্রাহকের দিকে মাত্র একটি data register; কোনো hardware FIFO নেই। 115200 baud-এ পরের byte পুরো আসে 86.8 µs পরে, আর তার আগে CPU আগেরটি না পড়লে overrun. তাই সাধারণ নকশা: RXNE-এর interrupt-এ ISR byte-টি তুলে একটি ring buffer-এ রাখে, আর main ধীরেসুস্থে লাইন জোড়ে। Ring buffer-এর নিয়ম (ISR শুধু head, main শুধু tail; data আগে, index পরে; ভরা হলে গোনা) আর মাপের হিসাব পর্ব ৪৩-এ বিস্তারিত; data structure-এর দিক DSA পর্ব ১৪-এ। এখানে আমরা সেটি একটি আসল UART-এ বসাব।

প্রথমে reference lab-এর uart_hello.c, কোর্সের virtual board-এ (BG-M3, আসল কোনো পণ্য নয়; Clang 22.1.8-এ Thumb কোডে compile, Unicorn-এ চলে, পর্ব ০৬). Board-এর UART-এর মডেল: TX-এ লেখা byte সঙ্গে সঙ্গে stdout-এ, RX আসে script থেকে, আর RXNEIE চালু থাকলে IRQ1 (Spec decision 24):

সত্যিকারের run — board.py run build/uart_hello.elf --script uart_hello.json (Clang 22.1.8)
[     0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[     0.0319 ms] UART: Hello from the Bazarghar board!
[    10.0000 ms] > UART RX 'ping\n'
[    10.0365 ms] UART: echo: PING
[    20.0000 ms] > UART RX 'bazar ghar\n'
[    20.0694 ms] UART: echo: BAZAR GHAR
[    20.0709 ms] exit(0) after 160567 cycles

এবার বাজারঘরের scale-এ একই কৌশল। আমার lab-এর scale_cmd.c reference-এর scale.c আর uart_hello.c জুড়ে বানানো: প্রতি 100 ms-এ ওজন মাপে আর বদল হলে README-র ধাঁচে দামের লাইন পাঠায়, আর UART-এ তিনটি কমান্ড নেয়: TARE, RATE <paisa/kg> আর P? (এখনই দামের লাইন). ISR অংশ:

#ifndef RB_SIZE
#define RB_SIZE 16u                        /* ২-এর ঘাত */
#endif
static volatile uint8_t rb[RB_SIZE];
static volatile uint32_t rb_head, rb_tail, rx_drops;

void UART_IRQHandler(void)
{
    while (UART->SR & UART_SR_RXNE) {
        uint8_t c = (uint8_t)UART->DR;     /* DR পড়লে RXNE মোছে */
        if (rb_head - rb_tail < RB_SIZE)
            rb[rb_head++ % RB_SIZE] = c;
        else
            rx_drops++;                    /* ভরা: ফেলে দিয়ে গোনা */
    }
}
/* main: rb_get() দিয়ে byte তুলে '\n' পর্যন্ত লাইন জোড়া, তারপর command(line);
   rx_drops বাড়লে "WARN rx overrun" ছাপা; খালি থাকলে cpsid → WFI → cpsie */

একটি সূক্ষ্ম কথা: rb[rb_head++ % RB_SIZE] = c একটি expression-এ দুটি store, আর C এদের ক্রম বেঁধে দেয় না; Clang 22.1.8 -O2 -S-এ আগে rb_head, পরে byte লেখা দেখা যায়। এখানে লেখক ISR নিজে, আর ISR চলার সময় main চলে না, তাই ক্ষতি নেই। কিন্তু লেখক main হলে (যেমন TX-এর buffer) আগে byte লিখে আলাদা statement-এ head বাড়ানো দরকার, তবেই “data আগে, index পরে” নিয়ম রক্ষা হয়।

Script-এ কম্পিউটার তিনবার লেখে: 150 ms-এ TARE, 420 ms-এ একসাথে দুটি কমান্ড RATE 6550 আর P? (১৩ byte), আর 600 ms-এ P?. একই firmware দুটি buffer-মাপে, ১৬ আর ৮:

সত্যিকারের run — board.py run build/scale_cmd.elf --script scale_cmd.json (RB_SIZE 16)
[   100.1020 ms] UART: raw=505 gross=150 g tare=0 g net=150 g price=9.83 Tk
[   150.0000 ms] > UART RX 'TARE\n'
[   150.0514 ms] UART: rx: head=5 tail=0 drops=0
[   150.0896 ms] UART: OK TARE 150 g
[   300.1168 ms] UART: raw=1380 gross=1400 g tare=150 g net=1250 g price=81.88 Tk
[   420.0000 ms] > UART RX 'RATE 6550\nP?\n'
[   420.0685 ms] UART: rx: head=18 tail=5 drops=0
[   420.1296 ms] UART: OK RATE 65.50 Tk/kg
[   420.2362 ms] UART: raw=1380 gross=1400 g tare=150 g net=1250 g price=81.88 Tk
[   600.0519 ms] UART: rx: head=21 tail=18 drops=0
[   600.1594 ms] UART: raw=1380 gross=1400 g tare=150 g net=1250 g price=81.88 Tk

সত্যিকারের run — একই script, build/scale_cmd8.elf (RB_SIZE 8)
[   420.0000 ms] > UART RX 'RATE 6550\nP?\n'
[   420.0666 ms] UART: rx: head=13 tail=5 drops=5
[   420.0983 ms] UART: WARN rx overrun, lost 5 bytes
[   600.0000 ms] > UART RX 'P?\n'
[   600.0519 ms] UART: rx: head=16 tail=13 drops=5
[   600.0754 ms] UART: ERR RATE

(দুই run-এর শুরুর অংশ হুবহু এক, তাই দ্বিতীয়টির শুধু বদলানো অংশ দেখানো হলো; পুরো output আমার lab-এর out/-এ।) দাম README-র সংখ্যার সঙ্গে মেলে: 150 g-এ 9.83 টাকা, ট্রে বাদ দিয়ে 1250 g আলুতে 81.88 টাকা। ৮ ঘরের buffer-এ কী ঘটল, নিচের stepper-এ:

ISRrb[head++ % 8] = DRISRভরা → rx_drops++mainc = rb[tail++ % 8]mainWARN rx overrunmain'\n' → command(line)
ধাপের পরে
সময়
head · tail · drops
rb[0..7]
main-এর line
  1. “TARE↵” এল, ৫ byte. ISR একবার ঢুকে while (RXNE)-এ পাঁচটিই তোলে: ঘর ০ থেকে ৪, head = 5. Board-এ script-এর byte একসাথে পৌঁছায় (baud-এর সময় মাপা হয় না), আসল chip-এ আসত 86.8 µs পরপর।
  2. main তুলে নিল। tail 5-এ পৌঁছায়, ‘↵’ পেয়ে লাইন “TARE” চালায়: ট্রের 150 g tare হলো।
  3. ১৩ byte-এর burst, জায়গা ৮. head 5 থেকে 12 পর্যন্ত ঘর ভরে: index 5, 6, 7-এ R, A, T, তারপর wrap করে 0 থেকে 4-এ E, ফাঁকা, 6, 5, 5. buffer ভরা (head − tail = 8), তাই বাকি “0↵P?↵” পাঁচটি byte ফেলে দেওয়া হলো: drops = 5.
  4. main সতর্ক করল, কিন্তু লাইন অসম্পূর্ণ। drops বেড়েছে দেখে WARN ছাপল, তারপর আটটি byte তুলে লাইনে রাখল “RATE 655”. ‘↵’ হারিয়ে গেছে, তাই কমান্ড এখনো চলেনি।
  5. পরের “P?↵” এল। ঘর 5, 6, 7-এ বসল (head 16). এখন হাতে পুরোনো ভাঙা টুকরোর পেছনে নতুন কমান্ড জুড়ে যাচ্ছে।
  6. দুটি কমান্ডই নষ্ট। লাইন হলো “RATE 655P?”. parser সংখ্যার পরে অক্ষর দেখে ERR RATE দিল, তাই দর বদলায়নি, দামের লাইনও যায়নি। ভাগ্য ভালো: ‘0’ হারিয়ে ‘↵’ টিকে থাকলে “RATE 655” গৃহীত হতো, দর হয়ে যেত 6.55 টাকা/kg.

শিক্ষা তিনটি। এক, buffer-এর মাপ ঠিক করে সবচেয়ে লম্বা burst আর main-এর সবচেয়ে লম্বা ব্যস্ততা: board-এ burst একসাথে আসে, তাই এটি এমন অবস্থার সমান যেখানে main ১৩ byte-এর সময় (115200 baud-এ প্রায় 1.13 ms) কিছুই পড়েনি। দুই, হারানো byte নীরবে ঢাকা যাবে না: rx_drops গোনা আর জানানো, আর overrun-এর পরে পরের ‘↵’ পর্যন্ত লাইন ফেলে দেওয়া (অনুশীলন ১-এর কাছাকাছি একটি উন্নতি). তিন, protocol নিজেই ভুল ধরুক: অংশ ৬-এর checksum.

এক লাইনের C, যার ক্রম আপনি ভাবছেন না: rb[rb_head++ % RB_SIZE] = c;-তে head-এর বাড়া আর ঘরে লেখা একই expression-এর দুটি side effect, আর C-তে এদের মধ্যে কোনো ক্রম বাঁধা নেই, volatile থাকলেও। Clang 22.1.8 -O2-এর আসল output-এ (আমার lab-এর txput.c) এই লেখায় আগে str head, পরে strb data. ISR লেখক হলে একক-core-এ ক্ষতি নেই, কারণ ISR চলার মাঝে main ঢুকতে পারে না (reference-এর uart_hello.c-ও তাই নিরাপদ). কিন্তু TX-এর buffer-এ লেখক main আর পাঠক ISR; সেখানে এই লেখা সত্যিকারের bug. ঠিক রূপ আলাদা বাক্যে: h = head; buf[h % N] = c; head = h + 1;. বিস্তারিত অনুশীলন ২-এ।

৬ · বাজারঘরের scale-এর কমান্ড — লাইন, checksum, TX-এর খরচ আর flow control

UART শুধু byte পৌঁছায়; byte-এর মানে ঠিক করে firmware-এর নিজের protocol. Scale-এর protocol সরল লেখার লাইন: প্রতিটি বার্তা ASCII-তে, শেষে ‘↵’ (\n, অনেক সময় \r\n). সুবিধা: মানুষ terminal-এ পড়তে আর লিখতে পারে। অসুবিধা: board-এর run দেখাল, একটি byte হারালে দুটি কমান্ড জুড়ে যায়, আর কপাল খারাপ হলে ভুল দর গৃহীত হয়। Parity এখানে কাজে আসে না, কারণ byte-টি নষ্ট হয়নি, হারিয়েছে।

সমাধান প্রতিটি লাইনে একটি checksum: GPS module-এর NMEA 0183 বার্তায় যেমন *hh, অর্থাৎ ‘*’-এর আগের সব byte-এর XOR, দুই hex অঙ্কে। scale ভুল checksum-এর কমান্ড ফেলে দেয় আর ERR পাঠায়, কম্পিউটার আবার পাঠায়। নিচের C কোড Wandbox-এ চলে:

#include <stdio.h>
#include <stdint.h>
#include <string.h>

/* "RATE 6550*24": '*'-এর আগের সব byte-এর XOR, দুই hex অঙ্কে */
static uint8_t xor_sum(const char *s, size_t n)
{
    uint8_t x = 0;
    for (size_t i = 0; i < n; i++)
        x ^= (uint8_t)s[i];
    return x;
}

static const char *check(const char *line)
{
    const char *star = strchr(line, '*');
    unsigned want;
    if (star == NULL || sscanf(star + 1, "%2X", &want) != 1)
        return "ERR no checksum";
    if (xor_sum(line, (size_t)(star - line)) != want)
        return "ERR checksum";
    return "OK";
}

int main(void)
{
    printf("XOR of \"RATE 6550\" = %02X\n", xor_sum("RATE 6550", 9));
    const char *tests[] = { "RATE 6550*24", "RATE 655*24", "RATE 6550*25",
                            "RATE 6505*24", "RATE 6550" };
    for (int i = 0; i < 5; i++)
        printf("%-13s -> %s\n", tests[i], check(tests[i]));
    return 0;
}

আসল আউটপুট (আমার lab-এ Clang 22.1.8, আর Wandbox-এ একই):

XOR of "RATE 6550" = 24
RATE 6550*24  -> OK
RATE 655*24   -> ERR checksum
RATE 6550*25  -> ERR checksum
RATE 6505*24  -> OK
RATE 6550     -> ERR no checksum

হারানো ‘0’ এবার ধরা পড়েছে: “RATE 655”-এর XOR 0x14, 0x24 নয়। কিন্তু চতুর্থ লাইনটি দেখুন: “6505” দুটি অঙ্কের জায়গা বদল, XOR-এ ক্রমের কোনো ভূমিকা নেই, তাই 65.05 টাকা/kg নীরবে গৃহীত। XOR checksum হারানো বা বদলানো byte ভালো ধরে, ক্রম বদল ধরে না। এই কারণেই Modbus RTU-র মতো protocol CRC-16 ব্যবহার করে (পর্ব ৫৩), যার তত্ত্ব Computer Networks পর্ব ০৯-এ। scale-এর ক্ষেত্রে আরেকটি সরল রক্ষা: scale “OK RATE 65.50 Tk/kg” ফেরত পাঠায়, আর কম্পিউটার সেটি নিজের পাঠানো মানের সঙ্গে মেলায়।

TX-এর খরচ — polling বনাম buffer

Reference-এর uart_putc() polling-এ লেখে: TXE 1 হওয়া পর্যন্ত ঘোরে, তারপর DR-এ byte. board-এ TXE সবসময় 1, কিন্তু আসল chip-এ ৬০ byte-এর দামের লাইন 115200 baud-এ 5.21 ms আর 9600 baud-এ 62.5 ms CPU-কে আটকে রাখে (brr.py-র শেষ লাইন). 9600 baud-এ তা scale-এর 100 ms মাপের সময়ের প্রায় দুই-তৃতীয়াংশ। সমাধান RX-এর আয়না: main একটি TX ring buffer-এ লেখে, আর TXE interrupt (STM32F1-এর CR1-এ TXEIE, বিট ৭) প্রতিবার DR খালি হলে পরের byte দেয়; buffer খালি হলে TXEIE বন্ধ। আরও বড় data বা উঁচু baud-এ CPU-কে পুরো বাদ দেয় DMA (পর্ব ৪৬): DMA RX-এ একটি circular buffer ভরে, আর UART-এর IDLE flag (লাইন এক frame-এর সময় চুপ) জানায় “একটি বার্তা শেষ”.

Flow control — গ্রাহক “থামুন” বলবে কীভাবে

Ring buffer-এর মাপ যতই হোক, প্রেরক যদি টানা গ্রাহকের চেয়ে দ্রুত পাঠায়, একসময় ভরবেই। তখন দরকার flow control, যাতে গ্রাহক প্রেরককে থামাতে পারে। দুটি প্রচলিত পথ:

  • Hardware (RTS/CTS): দুটি বাড়তি তার। প্রতিটি পক্ষের RTS যায় অন্য পক্ষের CTS-এ। গ্রাহকের buffer প্রায় ভরে এলে সে নিজের RTS নিষ্ক্রিয় করে; প্রেরকের UART CTS দেখে পরের byte শুরু করে না। STM32F1-এ CR3-এর RTSE আর CTSE বিট এটি hardware-এ চালায়, firmware-কে প্রতি byte দেখতে হয় না। সতর্কতা: প্রেরক যে byte ইতিমধ্যে পাঠানো শুরু করেছে, তা আসবেই, আর কম্পিউটারের দিকে USB-UART-এর ভেতরেও buffer থাকে; তাই “প্রায় ভরা” মানে কয়েক ডজন byte আগে থেকে।
  • Software (XON/XOFF): কোনো বাড়তি তার নেই; গ্রাহক data-র মধ্যেই XOFF (0x13) পাঠিয়ে থামতে আর XON (0x11) পাঠিয়ে আবার চালাতে বলে। শুধু লেখার data-য় চলে; binary data-য় 0x13 থাকলে বিভ্রাট।

বাজারঘরের scale-এর কমান্ড ছোট আর কম, তাই সেখানে flow control-এর চেয়ে checksum আর উত্তরের অপেক্ষাই যথেষ্ট: কম্পিউটার একটি কমান্ড পাঠিয়ে “OK” বা “ERR” পাওয়ার পরে পরেরটি পাঠায়। এই ধরনের “এক প্রশ্ন, এক উত্তর” নকশাকে handshake-ভিত্তিক নিয়ন্ত্রণ বলা যায়, আর এটি প্রায় সবসময় সবচেয়ে সরল flow control.

৭ · তারের ভোল্টেজ — TTL, RS-232, USB-UART আর নিরাপত্তা

এ পর্যন্ত “লাইন 1” আর “লাইন 0” বলেছি, কিন্তু তারে আসলে ভোল্টেজ। কোন ভোল্টেজ 1, তা ঠিক করে logic level, আর UART-এর জগতে তিন রকম চলে:

ধরনIdle / 10কোথায়
3.3 V TTL-স্তর (CMOS)প্রায় 3.3 Vপ্রায় 0 VSTM32, ESP32, RP2040, nRF52-এর pin
5 V TTL-স্তরপ্রায় 5 Vপ্রায় 0 VATmega328P-এর মতো 5 V-এর chip, পুরোনো module
RS-232ঋণাত্মক, প্রেরকে মোটামুটি −5 থেকে −15 V (mark)ধনাত্মক, +5 থেকে +15 V (space)পুরোনো PC-র DB9 port, শিল্পের যন্ত্র, কিছু ওজনের যন্ত্র আর POS প্রিন্টার

RS-232-এর গ্রাহক সাধারণত +3 V-এর ওপরে 0 আর −3 V-এর নিচে 1 ধরে; মাঝের অংশ অনির্ধারিত। লক্ষ্য করুন logic উল্টো: idle-এ লাইন ঋণাত্মক। তাই MCU আর RS-232-এর মাঝে একটি transceiver chip লাগে (MAX232-গোত্রের chip-এর নাম সবচেয়ে পরিচিত), যা ভোল্টেজ বদলায় আর উল্টায়। আজ কম্পিউটারের সঙ্গে সবচেয়ে প্রচলিত পথ একটি USB-UART bridge module, যা কম্পিউটারে একটি virtual COM port দেখায় আর অন্য পাশে TTL-স্তরের TX/RX দেয়; কেনার আগে দেখুন সেটি 3.3 V না 5 V স্তরের। 5 V আর 3.3 V-এর chip জুড়তে লাগে level shifter, অথবা অন্তত datasheet-এ দেখা যে 3.3 V-এর pin “5 V tolerant” কি না। আর তার জোড়ার নিয়ম: TX → RX, RX → TX, GND → GND; TX-কে TX-এ জুড়লে কিছু চলে না, আর GND না জুড়লে দুই পক্ষের “0 V” আলাদা।

নিরাপত্তা: RS-232-এর ±১০ V-এর মতো ভোল্টেজ সরাসরি 3.3 V-এর MCU pin-এ দিলে pin, এমনকি পুরো chip নষ্ট হতে পারে; ঋণাত্মক ভোল্টেজও একই রকম ক্ষতিকর। শুধু transceiver বা সঠিক স্তরের USB-UART দিয়ে জুড়ুন, আর অপরিচিত port-এ আগে multimeter-এ idle ভোল্টেজ মেপে নিন। ভারী যন্ত্র (মোটর, mains-চালিত মেশিন) থেকে UART টানতে হলে দুই পক্ষের GND-এর মধ্যে বড় পার্থক্য থাকতে পারে; সেখানে isolated (optocoupler বা digital isolator-যুক্ত) interface ব্যবহারের নিয়ম, আর mains-এর তার বা ভেতরের circuit নিজে কখনো খুলবেন না, যোগ্য technician-এর কাজ। লম্বা দূরত্ব আর শিল্পের পরিবেশের জন্য differential RS-485 (পর্ব ৫৩).

আরও গভীরে: RS-232 মান প্রথম প্রকাশ করে আমেরিকার EIA, ১৯৬০ সালে, টেলিটাইপ আর modem-কে কম্পিউটার-টার্মিনালের সঙ্গে জোড়ার জন্য; সবচেয়ে পরিচিত সংস্করণ RS-232-C (১৯৬৯), পরে নাম TIA-232. মানটি আসলে শুধু বৈদ্যুতিক স্তর আর সংকেতের তার (TxD, RxD, RTS, CTS, DTR, DSR, DCD …) বলে; start-stop frame এসেছে তারও আগের teleprinter-এর যান্ত্রিক যুগ থেকে। PC-র UART-এর ইতিহাসে একটি বড় বাঁক ছিল National Semiconductor-এর 16550A-এর ১৬ byte-এর FIFO, যা multitasking OS-এ উঁচু baud-এ byte হারানো অনেক কমায় বলে সাধারণত বলা হয়। আজকের অনেক MCU-তেও FIFO ফিরেছে, যেমন RP2040-এর দুটি UART ARM-এর PL011 নকশার, যার datasheet প্রতি দিকে ৩২ ঘরের FIFO দেয়; STM32F1-এর USART-এ কোনো FIFO নেই।

পরীক্ষা ও ইন্টারভিউতে:

  • 9600 baud, 8N1-এ সেকেন্ডে কয় byte? ১০ বিট/byte, তাই 960 byte/s; এক byte 1.04 ms.
  • 72 MHz-এ 115200 baud-এর STM32F1 BRR? USARTDIV = 39.0625 → 39 আর 1/16 → 0x271.
  • Parity কয়টি বিটের ভুল ধরে? যেকোনো বিজোড় সংখ্যক বিট; দুটি উল্টালে ধরা পড়ে না।
  • Framing আর overrun error-এর পার্থক্য? Framing: stop-এর জায়গায় 0 (baud বা লাইনের সমস্যা); overrun: CPU আগের byte পড়ার আগেই নতুনটি এসেছে (firmware-এর latency-র সমস্যা).
  • RX ISR-এ buffer ভরা হলে কী করবেন? byte ফেলে দিয়ে গোনা; ISR-এ অপেক্ষা কখনো নয়।

৮ · AI-এর যুগে UART কোড যাচাই

AI assistant UART-এর init আর ISR প্রায় সবসময় লিখে দেয়, আর কোডটি প্রায়ই প্রথম পরীক্ষায় চলে, কারণ টেবিলের ওপর ছোট তারে, কম data-য় সব ঠিক থাকে। ভুলগুলো বেরোয় ভিন্ন clock-এ, burst-এ বা লম্বা তারে। পরিচিত ভুল আর যাচাইয়ের উপায়:

AI প্রায়ই যা করেকীভাবে ধরবেন
BRR হিসাব করে ভুল clock দিয়ে (SYSCLK, অথচ USART2 চলে APB1-এ), বা BRR-এ সরাসরি USARTDIV লেখেclock tree থেকে নিজের PCLK বের করা; brr.py-র মতো হিসাব করে আসল baud আর ভুল % দেখা
ISR-এ printf বা TXE-র জন্য ঘোরা, অথবা ভরা buffer-এ অপেক্ষাISR-এ কোনো loop-এর শেষ RXNE ছাড়া অন্য কিছুর ওপর নির্ভর করে কি না দেখা
head/tail-এ volatile ভুলে যায়, বা buf[head++ % N] = c-এর ক্রমে ভরসা করেClang/GCC-এর -S output-এ store-এর ক্রম পড়া; লেখক-পাঠক কে, তা লেখা
ORE বা অন্য error flag মোছে না, ফলে interrupt থামে নাchip-এর reference manual-এ flag মোছার ক্রম পড়া; burst পাঠিয়ে পরীক্ষা
Register-এর নাম বা বিট আরেক পরিবারের chip থেকে আনে (যেমন STM32F1-এ ISR/RDR/TDR, যা নতুন STM32-এর নাম)নিজের chip-এর reference manual আর CMSIS header মেলানো
“RS-232” বলে TTL module, বা উল্টোmodule-এর datasheet; idle-এ multimeter: 3.3 V, 5 V নাকি ঋণাত্মক

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

আমি STM32F103-এ bare-metal C লিখছি (HAL নেই, CMSIS register দিয়ে). USART2, APB1 = 36 MHz, 115200 baud, 8N1. ১. BRR-এর মান হিসাব করে দেখাও: USARTDIV, mantissa, fraction, আসল baud আর ভুল %. কোন clock ধরেছ, স্পষ্ট বলো। ২. RXNE interrupt দিয়ে ৬৪ byte-এর ring buffer লেখো: ISR শুধু head, main শুধু tail বদলাবে; data আগে, head পরে, আলাদা বাক্যে। buffer ভরা হলে byte ফেলে একটি counter বাড়াও। ৩. ISR-এ PE, FE, NE, ORE দেখো, আর RM0008-এর নিয়মে কীভাবে মুছতে হয় বলো। ৪. ISR-এ কোনো printf, delay বা অপেক্ষা রাখবে না। ৫. কোনো register বা বিটের নাম দিলে RM0008-এর কোন অংশ থেকে, বলো; নিশ্চিত না হলে সেটি বলো।

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

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

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

প্র ০১RS-232 প্রায় ষাট বছরের পুরোনো, আর এর ভোল্টেজ আজকের chip-এর তুলনায় বিশাল ও উল্টো। তবু শিল্পে আর দোকানের যন্ত্রে এটি এখনো কেন টিকে আছে?

RS-232-এর জন্ম ১৯৬০ সালের দিকে, যখন কম্পিউটারের সঙ্গে টেলিটাইপ আর modem জোড়ার দরকার হয়েছিল। তখনকার circuit আর লম্বা তারের কথা ভেবে মানটি বড় ভোল্টেজের পথ নিয়েছিল: প্রেরক কয়েক ভোল্ট থেকে ±১৫ V পর্যন্ত, গ্রাহক ±৩ V-এর বাইরে হলে সিদ্ধান্ত নেয়। মাঝের ৬ V-এর অনির্ধারিত অংশ আর বড় দোলন noise-এর বিরুদ্ধে একটি মোটা নিরাপত্তা-সীমা দেয়, তাই কম গতিতে (9600 baud-এর মতো) কয়েক মিটার থেকে আরও লম্বা তারেও সাধারণত ঠিক চলে। ঋণাত্মক ভোল্টেজকে 1 (mark) ধরার নিয়মও এসেছে টেলিগ্রাফের যুগের “mark” আর “space” থেকে, যেখানে idle লাইনেও স্রোত বা সংকেত থাকত, ফলে তার কাটা পড়লে বোঝা যেত।

টিকে থাকার মূল কারণ অবশ্য প্রযুক্তি নয়, বাস্তবতা। শিল্পের যন্ত্র, ল্যাবের যন্ত্র, POS প্রিন্টার, ওজনের যন্ত্র আর অনেক নিয়ন্ত্রকের আয়ু কয়েক দশক; একটি কারখানা শুধু port বদলানোর জন্য সেগুলো ফেলে দেয় না। RS-232 প্রায় সব জায়গায় বোঝা যায়, কোনো driver লাগে না, terminal program দিয়েই পরীক্ষা করা যায়, আর কোনো জটিল enumeration নেই। তাই নতুন যন্ত্রেও নির্মাতারা একটি “service port” রাখেন, প্রায়ই RS-232 বা TTL UART.

এমবেডেড নকশাকারীর জন্য শিক্ষা হলো: MCU-র UART একই, শুধু বাইরের transceiver বদলায়। একই firmware TTL-এ USB-UART bridge দিয়ে কম্পিউটারে, RS-232 transceiver দিয়ে পুরোনো যন্ত্রে, আর RS-485 transceiver দিয়ে কারখানার বহু-যন্ত্রের লাইনে (পর্ব ৫৩) কথা বলতে পারে। নকশার সময় ঠিক করতে হয় কোন physical স্তর, আর সেই স্তরের নিরাপত্তা: সঠিক transceiver, GND-এর পার্থক্য হলে isolation, আর ভুল তারে জোড়া হলে যাতে কিছু না পোড়ে সেই সুরক্ষা।

মূল উপলব্ধি: UART একটি frame-এর নিয়ম, RS-232 একটি বৈদ্যুতিক মান; frame বদলায়নি বলেই নানা যুগের যন্ত্র আজও একে অন্যের সঙ্গে কথা বলতে পারে, আর transceiver সেই সেতু।

প্র ০২দুই প্রান্তের clock-এর ভুল মিলিয়ে কতটা চলে? একটি সস্তা RC oscillator-এ চলা MCU আর একটি crystal-যুক্ত কম্পিউটার UART-এ কথা বলবে; কীভাবে ঝুঁকি হিসাব করবেন?

শুরু হোক সীমা দিয়ে। এই পর্বের মডেলে আদর্শ সীমা 0.5 ÷ 9.5 ≈ ৫.২৬%: শেষ sample-এর আগে আধা বিটের বেশি সরে গেলে ভুল বিট। বাস্তবে এর থেকে কাটতে হয় তিনটি জিনিস: start-এর ধার চেনার অনিশ্চয়তা (১৬ গুণ oversampling-এ প্রায় ১/১৬ বিট), লাইনের ধারের ঢাল আর noise, আর গ্রাহকের তিন-নমুনার জানালা যা বিটের মাঝখানের একটু বাঁয়ে-ডানে ছড়ানো। STM32-এর কয়েকটি reference manual এই হিসাব করে ৮ data বিটে প্রায় 3.75% সহনশীলতা দেয়; ৯ বিট বা parity থাকলে frame লম্বা, তাই সীমা আরও কম। এটি দুই প্রান্তের মোট বাজেট।

এবার বাজেটে কে কতটা খায়। প্রথমে BRR-এর গোল করার ভুল, যা এই পর্বের টেবিলে: 8 MHz-এ 115200-এ +0.64%, 460800-এ +2.12%. তারপর clock-এর নিজের ভুল। Crystal সাধারণত কয়েক দশ ppm, অর্থাৎ শতাংশের হিসাবে প্রায় শূন্য। কিন্তু MCU-র ভেতরের RC oscillator অনেক কম নির্ভুল: STM32F103-এর HSI কারখানায় calibrate করা, কিন্তু datasheet-এর হিসাবে ঘরের তাপমাত্রাতেই এক-দুই শতাংশের মতো সরে থাকতে পারে, আর পুরো তাপমাত্রার পরিসরে আরও বেশি (পর্ব ৩৩-এ HSI-এর কথা). তাই HSI-তে 8 MHz, 460800 baud: গোল করার +2.12% আর তাপমাত্রায় আরও এক-দুই শতাংশ, মোট সীমার কাছে বা ওপরে। একই HSI-তে 115200 হলে +0.64% আর তাপমাত্রার অংশ, মোটামুটি নিরাপদ।

নকশার নিয়ম তাই: সব উৎস যোগ করে worst case দেখা, দুই প্রান্তের জন্যই। বাজারঘরের cold-storage monitor-এর কথা ভাবুন: যন্ত্রটি ঠান্ডা ঘরে থাকে, যেখানে RC oscillator ঘরের তাপমাত্রার মান থেকে সরে যেতে পারে, অথচ পরীক্ষা হয়েছিল টেবিলে। উপায়: উঁচু baud বা ঠান্ডা-গরম পরিবেশে crystal (HSE) ব্যবহার, কম baud বেছে নেওয়া যাতে ভাগফল বড় আর গোল করার ভুল ছোট হয়, অথবা কিছু chip-এর auto-baud সুবিধা, যা প্রথম byte মেপে নিজের BRR ঠিক করে। আর পরীক্ষার সময় ইচ্ছা করে BRR এক-দুই ধাপ সরিয়ে দেখা কোথায় ভাঙে, যাতে নিরাপত্তা-সীমা কত তা জানা যায়।

মূল উপলব্ধি: UART-এর নির্ভরযোগ্যতা একটি বাজেট: গ্রাহকের সহনশীলতার মধ্যে দুই প্রান্তের গোল করার ভুল আর clock-এর ভুল, সবচেয়ে খারাপ তাপমাত্রায়, আঁটতে হবে।

প্র ০৩Hardware-এর overrun (ORE) আর software ring buffer-এর “ভরা” দুটোই byte হারায়। পার্থক্য কোথায়, আর কোনটি কীভাবে সারাবেন?

Hardware overrun ঘটে UART-এর ভেতরে। STM32F1-এর মতো FIFO-হীন UART-এ গ্রাহকের দিকে একটি shift register আর একটি data register. একটি byte পুরো এলে data register-এ যায় আর RXNE ওঠে; তারপর থেকে CPU-র হাতে ঠিক এক frame-এর সময়, 115200 baud-এ 86.8 µs, পরের byte পুরো আসার আগে আগেরটি পড়ার জন্য। না পড়লে ORE: নতুন byte হারায় (STM32F1-এ data register-এ পুরোনোটি থাকে বলে RM0008 বলে). এই সমস্যা firmware-এর latency-র: কোনো ISR অনেকক্ষণ চলেছে, বা কোথাও interrupt অনেকক্ষণ বন্ধ ছিল। পর্ব ৪৩-এর latency-র হিসাব ঠিক এর জন্য: UART RX-কে সবচেয়ে কম deadline-এর কাজ ধরে সবচেয়ে বেশি জরুরি priority দেওয়া, আর critical section ছোট রাখা।

Software-এর ভরা buffer ঘটে ISR আর main-এর মাঝখানে। ISR প্রতিটি byte ঠিক সময়ে তুলেছে, কিন্তু main অনেকক্ষণ কিছু পড়েনি, তাই ring buffer ভরে গেছে। এই পর্বের board-এর run এটিই দেখাল: ১৩ byte-এর burst, ৮ ঘর, ৫টি byte গেছে। সারানোর পথ ভিন্ন: buffer-এর মাপ বাড়ানো (সবচেয়ে লম্বা ব্যস্ততা × আগমনের হার), main-এর লম্বা কাজ ভেঙে ছোট করা, বা RTOS-এ UART-এর task-কে বেশি priority. আর প্রেরককে থামানোর ব্যবস্থা: RTS/CTS, XON/XOFF, বা প্রশ্ন-উত্তরের protocol.

দুই ক্ষেত্রেই একটি জিনিস সমান জরুরি: হারানো জানা। ORE-এর বিট পড়া আর গোনা, ring-এর drops গোনা, আর বার্তার স্তরে checksum, যাতে ভাঙা কমান্ড কাজে না লাগে। লক্ষ্য করুন, কোর্সের board hardware overrun দেখাতে পারে না, কারণ তার RX queue সীমাহীন আর baud-এর সময় মাপে না (Spec decision 24); তাই এই পর্বে overrun এসেছে software buffer থেকে। আসল chip-এ দুটিই সম্ভব, আর debug-এর সময় প্রথম প্রশ্ন: ORE উঠেছে, নাকি drops বেড়েছে? উত্তর বলে দেয় সমস্যা ISR-এর latency-তে, নাকি main-এর গতিতে।

মূল উপলব্ধি: ORE মানে ISR দেরি করেছে, ring-এর drops মানে main দেরি করেছে; দুটি আলাদা গোনা থাকলে কোথায় সারাতে হবে, তা সঙ্গে সঙ্গে বোঝা যায়।

প্র ০৪Parity আজকের বেশিরভাগ UART সংযোগে বন্ধ (8N1). তাহলে ভুল ধরা হয় কোথায়? Parity, checksum আর CRC-এর মধ্যে কোনটি কখন?

Parity প্রতিটি byte-এ একটি বিট খরচ করে (১১ বিটের 8E1-এ কাজের ভাগ 72.7%, 8N1-এ 80%), আর ধরে শুধু বিজোড় সংখ্যক বিটের ভুল। এই পর্বের মডেলে দুটি বিট উল্টে ‘T’ হয়ে গেল ‘@’, আর parity বলল সব ঠিক। তার চেয়েও বড় কথা, UART-এর বাস্তব ভুলের বেশিরভাগ বিট উল্টানো নয়: byte হারানো (overrun, ভরা buffer), baud না মেলা, বা তার খুলে যাওয়া। board-এর run-এ “RATE 6550”-এর পাঁচটি byte হারিয়েছিল, প্রতিটি পৌঁছানো byte নিখুঁত ছিল, তাই parity কিছুই ধরত না। এ কারণেই অনেক নকশা parity বাদ দেয়, আর ভুল ধরার দায়িত্ব দেয় বার্তার স্তরে।

বার্তার স্তরে প্রথম ধাপ সরল checksum, যেমন NMEA 0183-এর XOR. GPS module-এর প্রতিটি বাক্য শেষ হয় *hh দিয়ে, যা ‘$’ আর ‘*’-এর মাঝের সব অক্ষরের XOR. সস্তা, হাতে হিসাব করা যায়, হারানো বা বদলানো byte ভালো ধরে। কিন্তু cksum.c দেখাল এর অন্ধ জায়গা: XOR ক্রম দেখে না, তাই “6550” আর “6505” একই। যোগফলের checksum-ও একই দুর্বলতায় ভোগে।

CRC (cyclic redundancy check) এই সমস্যা মেটায়। এটি বার্তাকে একটি বহুপদীর ভাগশেষ হিসেবে দেখে, তাই প্রতিটি বিটের অবস্থান ফলকে প্রভাবিত করে; নির্দিষ্ট দৈর্ঘ্যের মধ্যে সব একক আর দ্বি-বিট ভুল, আর CRC-র দৈর্ঘ্যের সমান বা ছোট সব burst ভুল নিশ্চিতভাবে ধরে। Modbus RTU প্রতিটি frame-এ CRC-16 দেয় (পর্ব ৫৩), Ethernet CRC-32. খরচ: কয়েক ডজন নির্দেশ প্রতি byte, বা একটি ছোট টেবিল; অনেক MCU-তে hardware CRC unit-ও থাকে। বাছাইয়ের নিয়ম মোটামুটি: মানুষ পড়বে আর ঝুঁকি কম, তাহলে লেখার লাইন আর XOR checksum; যন্ত্রে যন্ত্রে binary data বা টাকার হিসাবের মতো জরুরি মান, তাহলে CRC, সঙ্গে উত্তরে মান ফেরত পাঠিয়ে মেলানো।

মূল উপলব্ধি: UART-এর বেশিরভাগ ভুল হারানো byte, উল্টানো বিট নয়; তাই নির্ভরযোগ্যতা আসে বার্তার স্তরের checksum বা CRC আর প্রশ্ন-উত্তরের নকশা থেকে, parity থেকে নয়।

প্র ০৫UART-এ data নেওয়ার তিন পথ: polling, প্রতি byte-এ interrupt আর DMA. বাজারঘরের scale আর একটি দ্রুত GPS বা cellular module-এর জন্য কোনটি কেন?

Polling মানে main নিজে বারবার RXNE দেখে। সরল, কোনো race নেই, কিন্তু FIFO-হীন UART-এ main-কে প্রতি frame-এর সময়ের মধ্যে অন্তত একবার দেখতে হবে: 115200 baud-এ প্রতি 86.8 µs. scale-এর main প্রতি 100 ms-এ ADC পড়ে, দামের লাইন পাঠায় (9600 baud-এ 62.5 ms পর্যন্ত), তাই polling-এ byte হারাবেই। Polling চলে শুধু খুব ধীর বা প্রশ্ন-উত্তরের ক্ষেত্রে, যেখানে main জানে কখন উত্তর আসবে আর তখন অন্য কিছু করে না।

প্রতি byte-এ interrupt, এই পর্বের নকশা। প্রতিটি byte-এর খরচ: interrupt-এ ঢোকা-বেরোনো (আসল Cortex-M3-এ প্রবেশে প্রায় ১২ cycle, ফেরায় আরও কিছু) আর ISR-এর নিজের কয়েক ডজন নির্দেশ। 72 MHz-এ 115200 baud-এ প্রতি byte-এর বাজেট প্রায় ৬২৫০ cycle, তাই কয়েক ডজন cycle নগণ্য। scale-এর জন্য এটি যথেষ্ট আর সবচেয়ে সরল: কমান্ড ছোট, কম আসে। হিসাব বদলায় দ্রুত আর ঘন data-য়: 921600 baud-এ টানা আসা একটি cellular modem-এর data-য় প্রতি byte মাত্র প্রায় 10.9 µs, আর সেকেন্ডে প্রায় ৯২,০০০ interrupt; CPU-র একটি অর্থবহ অংশ শুধু ঢোকা-বেরোনোয় যায়, আর অন্য কোনো ISR একটু লম্বা হলেই overrun.

DMA এখানে আসে (পর্ব ৪৬). UART-এর RXNE সরাসরি DMA-কে বলে byte-টি একটি circular buffer-এ লিখতে; CPU কিছুই করে না। main জানবে কীভাবে কতটা এসেছে? DMA-র অর্ধেক আর পুরো ভরার interrupt, আর UART-এর IDLE flag: লাইন একটি frame-এর সময় চুপ থাকলে ওঠে, অর্থাৎ “একটি বার্তা শেষ”. GPS module-এর মতো যন্ত্র, যা প্রতি সেকেন্ডে কয়েকশো byte-এর বাক্যের ঝাঁক পাঠায়, তার জন্য DMA + IDLE প্রায় আদর্শ। আর যে chip-এ hardware FIFO আছে (যেমন RP2040-এর PL011), সেখানে interrupt আসে কয়েকটি byte জমলে, যা মাঝামাঝি একটি পথ। পছন্দের নিয়ম তাই সংখ্যায়: baud আর data-র ঘনত্ব থেকে interrupt-এর হার, CPU-র বাজেট আর সবচেয়ে খারাপ latency.

মূল উপলব্ধি: ধীর আর বিরল কমান্ডে প্রতি byte-এ interrupt, দ্রুত আর ঘন data-য় DMA বা FIFO; polling শুধু যখন main নিজেই অপেক্ষা করছে।

অনুশীলন

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

  1. নকশা ও বাস্তবায়ন — interrupt-চালিত TX: STM32F1-ধাঁচের UART-এ main-এর জন্য uart_send(const char *s) লিখুন, যা অপেক্ষা না করে একটি ৬৪ byte-এর TX ring buffer-এ লেখে, আর TXE interrupt (CR1-এর TXEIE, বিট ৭) প্রতিবার DR খালি হলে পরের byte দেয়। buffer ভরা থাকলে কী করবেন, আর TXEIE কখন চালু-বন্ধ হবে?
    #define TXN 64u
    static volatile uint8_t  tx[TXN];
    static volatile uint32_t tx_head, tx_tail, tx_drops;   /* head: main, tail: ISR */
    
    void uart_send(const char *s)
    {
        while (*s) {
            uint32_t h = tx_head;
            if (h - tx_tail == TXN) { tx_drops++; s++; continue; }  /* ভরা */
            tx[h % TXN] = (uint8_t)*s++;      /* আগে data */
            tx_head = h + 1;                  /* তারপর head */
        }
        UART->CR1 |= UART_CR1_TXEIE;          /* পাঠানো শুরু বা চালু রাখা */
    }
    
    void UART_IRQHandler(void)                /* RX অংশ আগের মতোই */
    {
        if ((UART->CR1 & UART_CR1_TXEIE) && (UART->SR & UART_SR_TXE)) {
            uint32_t t = tx_tail;
            if (t == tx_head) {
                UART->CR1 &= ~UART_CR1_TXEIE; /* আর কিছু নেই: বন্ধ */
            } else {
                UART->DR = tx[t % TXN];
                tx_tail = t + 1;
            }
        }
    }

    মূল কথা: TXE খালি data register-এ সবসময় 1, তাই TXEIE চালু রেখে দিলে buffer খালি অবস্থায় interrupt থামবে না; শেষ byte দেওয়ার পরে বন্ধ করতে হয়। ভরা buffer-এ এখানে byte ফেলে গোনা হয়েছে; দামের লাইনের মতো জরুরি বার্তায় বিকল্প হলো main-এ অপেক্ষা করা (কখনো ISR-এ নয়). একটি সূক্ষ্মতা: main-এর CR1 |= TXEIE একটি read-modify-write, আর ISR-ও CR1 বদলায়; তাই এই লাইনটি একটি ছোট critical section-এ রাখা নিরাপদ (পর্ব ৩৫, ৪৩). UART_CR1_TXEIE নামটি আপনাকে নিজে বিট ৭ দিয়ে define করতে হবে; কোর্সের board-এ TXE interrupt নেই (Spec decision 24: শুধু RX-এর IRQ), তাই এই কোড আসল STM32F1-এর জন্য নকশা, board-এ চালানো হয়নি। লেখার ক্রম (data আগে, head পরে, আলাদা বাক্যে) অনুশীলন ২-এর কারণে।

  2. ভুল খুঁজুন — TX buffer-এর এক লাইন: একজন অনুশীলন ১-এর uart_send-এ লিখলেন tx[tx_head++ % TXN] = c;. পরীক্ষায় মাঝে মাঝে terminal-এ একটি পুরোনো অক্ষর আসে, যা আগের লাইনের। Cortex-M3-এ Clang 22.1.8 -O2 এই লাইন থেকে বানায়:
    put_bad:
        ldr   r2, [r1]        @ r2 = tx_head
        adds  r3, r2, #1
        str   r3, [r1]        @ tx_head = r2 + 1
        and   r1, r2, #63
        ...
        strb  r0, [r2, r1]    @ tx[r2 % 64] = c
    কোথায় সমস্যা, আর ঠিক রূপ কী?

    head-এর store (str) data-র store (strb)-এর আগে। দুটির মাঝে TXE interrupt এলে ISR দেখে tail != head, আর ঘরটি পাঠায়, যেখানে এখনো ৬৪ byte আগের পুরোনো অক্ষর বসে আছে। ফলে terminal-এ পুরোনো অক্ষর, আর নতুন অক্ষরটি পরে লেখা হলেও কখনো যায় না। C-তে tx_head++-এর side effect আর ঘরে লেখা একই expression-এর ভেতরে, এদের মধ্যে কোনো sequence point নেই, তাই দুটি volatile হলেও compiler যেকোনো ক্রমে করতে পারে, আর Clang সত্যিই উল্টো ক্রম নিয়েছে। ঠিক রূপ আলাদা বাক্যে:

    void put_good(uint8_t c) { uint32_t h = tx_head; tx[h % N] = c; tx_head = h + 1; }

    একই Clang-এ এর output: আগে strb r0, [r1, r3] (data), তারপর str.w r0, [r12] (head), আমার lab-এর txput.c-তে দুটিই compile করে দেখা। এখানে দুটি বাক্যের মাঝে sequence point আছে, আর দুটি access-ই volatile, তাই C নিয়ম অনুযায়ী ক্রম রাখতে হয়। RX-এর ISR-এ একই এক-লাইন লেখা একক-core-এ নিরাপদ, কারণ ISR-এর মাঝে main ঢোকে না; কিন্তু অভ্যাস হিসেবে দুই দিকেই আলাদা বাক্য লিখুন।

  3. হিসাব — 36 MHz-এ 9600 baud আর buffer-এর মাপ: একটি STM32F1-এর USART2 চলে 36 MHz-এ। (ক) 9600 baud-এর BRR, আসল baud আর ভুল %? (খ) একই baud কোর্সের board-এর 8 MHz-এ? (গ) একই chip 115200 baud, 8N1-এ টানা data পায়, আর main-এর সবচেয়ে লম্বা ব্যস্ততা 20 ms. RX ring buffer অন্তত কত ঘরের, আর ২-এর ঘাতে কত নেবেন?

    (ক) 36,000,000 ÷ 9600 = 3750 = 0xEA6 → USARTDIV = 234 + 6/16 = 234.375; আসল baud 36,000,000 ÷ 3750 = 9600, ভুল 0%. (খ) 8,000,000 ÷ 9600 = 833.33, নিকটতম 833 = 0x341 → 52 + 1/16; আসল baud 9603.8, ভুল +0.04%. দুটিই brr.py-র টেবিলে আছে। (গ) এক byte = 10 ÷ 115200 s = 86.8 µs; 20 ms-এ 20 ÷ 0.0868 = 230.4, অর্থাৎ 231টি byte আসতে পারে (শুরুতে আংশিক frame ধরলে)। ২-এর ঘাতে 256 ঘর, যাতে % size একটি AND হয় আর index-এর wrap নিরাপদ থাকে (পর্ব ৪৩). হিসাব আমার lab-এর practice.py-তে চালিয়ে মেলানো। মনে রাখবেন, 256 ঘর মানে 20 ms-এর পরেও প্রায় ২৫টি byte-এর বাড়তি জায়গা; ব্যস্ততা মাপা না থাকলে আরও বড়, বা DMA.

  4. আগে বলুন — 8E1-এ ‘1’: প্রেরক 8E1-এ ASCII '1' (0x31) পাঠায়। (ক) লাইনে start থেকে stop পর্যন্ত ১১টি বিট লিখুন। (খ) পথে D3 উল্টে গেলে গ্রাহক কোন byte পায় আর কোন flag ওঠে?

    (ক) 0x31 = 0011 0001; LSB আগে D0…D7 = 1 0 0 0 1 1 0 0. data-য় তিনটি 1, তাই even parity P = 1. লাইনে: 0 10001100 1 1, একসাথে 01000110011. (খ) D3 0 থেকে 1: data D0…D7 = 1 0 0 1 1 1 0 0 = 0x39, যা ASCII '9'. এখন data-য় চারটি 1, আর P = 1 মিলিয়ে পাঁচটি, বিজোড়: parity error (PE). গ্রাহক byte-টি ফেলে দিলে ‘1’-এর বদলে কোনো ভুল সংখ্যা দামের হিসাবে ঢোকে না। frame.py-র frame আর unframe দিয়ে চালানো: 0x31 8E1: 01000110011, D3 flipped: 01001110011 -> parity error (0x39). parity না থাকলে (8N1) গ্রাহক ‘9’ নিয়ে নিত, কোনো সংকেত ছাড়াই।

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

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

ক্রমএকটি microcontroller-এর UART RXNE interrupt দিয়ে byte একটি ring buffer-এ রাখে, আর main সেখান থেকে লাইন জোড়ে। একটি byte-এর পথের ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. Idle লাইন 1 থেকে 0-তে নামে, গ্রাহক start-এর ধার চেনে
  2. আধা বিট পরে আবার দেখে নিশ্চিত হয় এটি আসল start
  3. প্রতিটি বিটের মাঝখানে sample নিয়ে data, parity আর stop পড়ে
  4. byte data register-এ যায় আর RXNE = 1 হয়
  5. ISR DR পড়ে (RXNE মোছে) আর byte ring buffer-এ রেখে head বাড়ায়
  6. main tail থেকে byte তুলে লাইনে জোড়ে

একটি UART 115200 baud-এ 8N1 frame-এ টানা data পাঠায়। সেকেন্ডে সর্বোচ্চ কয়টি data byte যায়?

  • 14400
  • 115200
  • 11520
  • 10473

STM32F1-ধাঁচের UART-এ baud = fCK ÷ (16 × USARTDIV), আর BRR-এ USARTDIV-এর পূর্ণ অংশ বিট 15–4-এ, ষোলো ভাগের ভগ্নাংশ বিট 3–0-এ। fCK = 72 MHz, 115200 baud-এর জন্য BRR কত?

  • 0x0027
  • 0x0271
  • 0x1D4C
  • 0x0625

একটি সংযোগ 8E1 (even parity). পথে একটি byte-এর ঠিক দুটি data বিট উল্টে গেল। গ্রাহক কী করবে?

  • Parity error দেবে
  • Framing error দেবে
  • Overrun error দেবে
  • ভুল byte-টি কোনো error ছাড়াই গ্রহণ করবে

পুরোনো একটি ওজনের যন্ত্রের DB9 RS-232 port থেকে data একটি 3.3 V-এর microcontroller-এর RX pin-এ নিতে হবে। ঠিক পথ কোনটি?

  • TX তার সরাসরি RX pin-এ, GND-এ GND
  • একটি resistor দিয়ে ভোল্টেজ ভাগ করে RX pin-এ
  • 3.3 V-এ চলা একটি RS-232 transceiver chip-এর মাধ্যমে, GND জুড়ে
  • একটি 5 V থেকে 3.3 V-এর level shifter দিয়ে

একটি UART RX ISR byte-গুলো ৮ ঘরের ring buffer-এ রাখে (ISR শুধু head, main শুধু tail বদলায়). main ব্যস্ত থাকায় buffer ভরে গেল, আর আরও byte আসছে। ISR-এর সঠিক আচরণ কোনটি?

  • main জায়গা খালি না করা পর্যন্ত ISR-এর ভেতরে অপেক্ষা করা
  • নতুন byte ফেলে দিয়ে হারানো byte-এর সংখ্যা গোনা
  • tail নিজে বাড়িয়ে পুরোনো byte-এর ওপরে লেখা, কাউকে না জানিয়ে
  • DR না পড়ে ISR থেকে ফিরে যাওয়া, যাতে byte UART-এ থেকে যায়

একটি UART-এর প্রেরকের baud গ্রাহকের চেয়ে প্রায় ৬% বেশি, frame 8N1, আর frame-এর পরে লাইন idle (1). গ্রাহক প্রতিটি বিটের মাঝখানে sample নেয়। 0x54 পাঠালে সাধারণত কী হয়?

  • সব বিট ঠিক, কারণ start-এর ধারে প্রতিবার আবার মেলানো হয়
  • সবসময় framing error
  • Parity error
  • শেষ data বিট ভুল পড়ে 0xD4, আর কোনো error flag ওঠে না

শব্দকোষ

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

মনে রাখুন

  1. Frame: idle 1 → start 0 → data, LSB আগে → parity (ঐচ্ছিক) → stop 1. 8N1 = ১০ বিট, 115200 baud-এ এক byte 86.8 µs, সেকেন্ডে ১১,৫২০ byte.
  2. BRR: baud = fCK ÷ (16 × USARTDIV); BRR = নিকটতম (fCK ÷ baud). 72 MHz-এ 115200 → 0x271, 8 MHz-এ → 69 (+0.64%). ভাগফল ছোট হলে ভুল বড়।
  3. সহনশীলতা: আদর্শ সীমা প্রায় ৫.২৬%, বাস্তবে দুই প্রান্ত মিলিয়ে কয়েক শতাংশ (STM32-এর কিছু manual-এ প্রায় 3.75%). সীমা পেরোলে ভুল byte, কখনো কোনো flag ছাড়াই।
  4. RX: RXNE interrupt → ring buffer (ISR head, main tail, data আগে, index পরে, আলাদা বাক্যে) → main-এ লাইন; ভরা হলে ফেলে গোনা; ORE আর drops আলাদা গুনুন; বার্তায় checksum বা CRC.
  5. তার: TX→RX, RX→TX, GND→GND. TTL (3.3 V/5 V) আর RS-232 (±৫–১৫ V, উল্টো) সরাসরি জোড়া যায় না; transceiver, USB-UART বা level shifter. Flow control: RTS/CTS বা XON/XOFF.

পরের পর্বে: পর্ব ৫০ (SPI — clock polarity, phase, chip select আর full duplex). UART-এর “তাল মেলানো”-র ঝামেলা নেই, কারণ master নিজেই clock দেয়: CPOL আর CPHA-র চারটি mode, shift register-এর বিনিময় আর একাধিক যন্ত্রের chip select.

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

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