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

GPIO — input, output, pull-up, pull-down আর open-drain

GPIO Basics — Input, Output, Pull-up, Pull-down and Open-Drain

Taught in Bangla, this lesson explains GPIO input modes (floating, pull-up, pull-down, analog), push-pull and open-drain outputs with wired-AND, alternate functions, and the STM32F103 CRL/CRH, IDR, ODR, BSRR and BRR registers. Real C firmware compiled with Clang runs on the course's virtual BG-M3 board in Unicorn, configuring pins register by register and reading a scripted active-low button (IDR 0x0000 pressed, 0x0001 released). In-page Python models shared lines and sizes an LED resistor and pull-ups.

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

  • একটি GPIO pin-এর ভেতরের input পথ, output driver, pull resistor আর সুরক্ষা diode-এর ছবি মনে গেঁথে নেওয়া
  • কোন কাজে কোন mode: floating, pull-up, pull-down, analog, push-pull, open-drain আর alternate function
  • STM32F103-এর CRL/CRH-এর CNF আর MODE বিট হিসাব করে একটি pin সাজানো, আর কোর্সের board-এর সরল DIR register-এর সঙ্গে তুলনা
  • Virtual বাজারঘর board-এ আসল firmware চালিয়ে LED জ্বালানো আর একটি active-low বোতাম পড়া
  • LED-এর resistor, pull-up-এর current, open-drain লাইনের ওঠার সময় আর input সুরক্ষার মৌলিক হিসাব

১ · GPIO কী — একটি pin, অনেক পরিচয়

বাজারঘরের দোকানের সামনের দরজাটি ভাবুন। সকালে দরজা দিয়ে মাল ঢোকে, দুপুরে খদ্দেরের হাতে মাল বেরোয়, রাতে দরজা বন্ধ, কেউ ঢোকে না, কেউ বেরোয় না। একই দরজা, তিন রকম কাজ; কোন সময় কোন কাজ, তা ঠিক করেন দোকানের মালিক। Microcontroller-এর একটি GPIO pin ঠিক এমন একটি দরজা। General-purpose input/output মানে “সাধারণ কাজের input বা output”: firmware ঠিক করে দেয় pin-টি বাইরের জগৎ থেকে খবর আনবে (input), বাইরে কিছু চালাবে (output), নাকি অন্য কোনো peripheral-এর, যেমন UART বা timer-এর, হাতে ছেড়ে দেওয়া হবে।

বাজারঘরের দুটি device-এর সব কিছুর শুরু GPIO দিয়ে। Smart scale-এর tare বোতাম একটি input pin. Cold-storage monitor-এর লাল alarm বাতি একটি output pin. পরে I2C-র temperature sensor-এর দুটি তার (পর্ব ৫১) আর UART-এর TX pin (পর্ব ৪৯)-ও আসলে GPIO pin, শুধু অন্য peripheral-এর হাতে দেওয়া। তাই এই পর্বটি মডিউল ৭-এর ভিত্তি: পরের পর্বের debouncing, interrupt, timer আর PWM সবই এই pin-গুলোর ওপর দাঁড়িয়ে।

8085-এর যুগে একটি output port বানাতে বাইরে 74LS373 latch আর input port-এর জন্য 74LS244 buffer লাগত, সঙ্গে address decoder; সেই ছবি পর্ব ২৩-এ। 8255 একসাথে ২৪টি programmable pin দিয়েছিল (পর্ব ২৪)। আজকের microcontroller সেই সব কিছু chip-এর ভেতরে এনে প্রতিটি pin-এর পাশে বসিয়েছে: latch-এর জায়গায় output data register, buffer-এর জায়গায় input data register, আর প্রতিটি pin আলাদা করে input বা output. সব register বসে মেমরির ঠিকানায় (memory-mapped I/O), তাই C-তে সাধারণ pointer দিয়েই পড়া-লেখা যায় (পর্ব ৩৬)।

লেখার নিয়ম আর lab: এই পর্বে hex লেখা হয় C-র ধাঁচে, যেমন 0x40010800. Board-এর সব মান এসেছে নিজের lab-এ আসল build আর run থেকে: firmware C-তে লেখা, Clang 22.1.8 দিয়ে compile করা (PyPI-র ziglang 0.17.1, MIT; LLVM অংশ Apache-2.0 with LLVM exception), চালানো হয়েছে কোর্সের virtual বাজারঘর board BG-M3-এ (Unicorn 2.1.4: binding BSD, engine GPLv2). BG-M3 কোনো আসল পণ্য নয়; আসল Cortex-M3 chip-এর আদলে বানানো শেখার মডেল (পর্ব ০৬; reference lab-এর README, Spec decision 17). STM32F103-এর তথ্য ST-এর reference manual RM0008-এর অধ্যায় ৯ থেকে নেওয়া; হাতে কোনো আসল board বা oscilloscope ছিল না।

কোর্সের board-এর GPIO ইচ্ছে করে সরল রাখা হয়েছে, যাতে প্রথম দিনেই register-এর কাজ বোঝা যায়। নিচের সারণিতে পাশাপাশি board আর একটি আসল chip, STM32F103-এর port A. লক্ষ করুন, IDR থেকে BRR পর্যন্ত offset দুই জায়গায় হুবহু এক; পার্থক্য শুধু প্রথম দুটি register-এ, যেখানে আসল chip প্রতিটি pin-এর mode, গতি আর pull বাছতে অনেক বেশি বিট রাখে।

Offsetবাজারঘর board (0x40010800)STM32F103 (0x40010800)কাজ
0x00DIR: বিট = 1 হলে outputCRL: pin ০–৭, প্রতি pin ৪ বিটpin-এর দিক বা mode
0x04(খালি)CRH: pin ৮–১৫mode, pin ৮–১৫
0x08IDRIDRpin-এর আসল অবস্থা, শুধু পড়া
0x0CODRODRoutput-এর মান; STM32-এ pull বাছাইও
0x10BSRRBSRRবিট ১৫–০ set, ৩১–১৬ reset; শুধু লেখা
0x14BRRBRRবিট ১৫–০ reset; শুধু লেখা
0x18(নেই)LCKRpin-এর সাজানো তালাবদ্ধ করা

Board-এর pin তিনটি (README, Spec decision 23): PA0-তে বোতাম, PA5-এ সবুজ LED (1 = জ্বলে), PA6-এ লাল alarm. Board ধরে নেয় PA0-র বোতাম বাইরের একটি pull-down resistor-এর সঙ্গে জোড়া, তাই সেখানে চাপলে 1. এই পর্বের অংশ ৭-এ আমরা উল্টো, বেশি প্রচলিত ধরনটি, অর্থাৎ pull-up আর চাপলে 0, board-এর script দিয়ে মডেল করব। কোনো pin-এর আচরণ কোথা থেকে আসে, register থেকে না বাইরের তার থেকে, এই পার্থক্যটি গোটা পর্বে বারবার ফিরে আসবে।

২ · একটি pin-এর ভেতরে — input পথ, output driver আর সুরক্ষা

Register-এ যাওয়ার আগে silicon-এর ভেতরের ছবিটি দেখা দরকার, কারণ প্রতিটি mode আসলে এই ছবির কোনো অংশ চালু বা বন্ধ করা। RM0008-এর চিত্র ১৩-এ STM32F1-এর একটি I/O pin-এর গঠন আছে; নিচের ছবিটি সেটিকে সরল করে আঁকা। ডান দিকে chip-এর বাইরের pin (pad), মাঝে একটি অনুভূমিক তার যাতে সবকিছু জোড়া।

ছবি ৪১.১ — একটি GPIO pin-এর ভেতরে (সরল করা)

ওপরে-নিচে দুটি transistor মিলে output driver; মাঝের তারে weak pull-up, pull-down আর দুটি সুরক্ষা diode; বাঁয়ে Schmitt trigger হয়ে IDR

GPIO pin-এর ভেতরের গঠন ODR P-MOS N-MOS Schmitt IDR PA5 VDD VSS output control pull-up pull-down diode diode পড়ার পথ
ছবি ৪১.১ — Push-pull-এ output control দুটি transistor-ই চালায়: ODR = 1 হলে P-MOS pin-কে VDD-তে টানে, 0 হলে N-MOS VSS-এ। Open-drain-এ P-MOS কখনো চালু হয় না (RM0008 §9.1.8). Input-এ দুটি transistor বন্ধ, আর pull-up বা pull-down-এর সুইচ (weak, প্রায় 40 kΩ) mode অনুযায়ী জোড়া বা খোলা। Schmitt trigger input আর output দুই mode-এই চালু থাকে, তাই output pin-এর অবস্থাও IDR-এ পড়া যায়; analog mode-এ সেটি বন্ধ হয়ে pin সরাসরি ADC-র দিকে যায়।

ছবির প্রতিটি অংশের একটি কাজ। Output driver দুটি transistor: P-MOS ওপরে, VDD-এর সঙ্গে; N-MOS নিচে, মাটির (VSS) সঙ্গে। এদের CMOS জোড়ার মূল ধারণা Computer Architecture-এর পর্ব ০৮-এ; এখানে শুধু মনে রাখুন, একটি চালু মানে pin সেই দিকে টানা। পড়ার পথে একটি Schmitt trigger, যা ধীরে ওঠা-নামা বা কাঁপা ভোল্টেজকেও পরিষ্কার 0 বা 1 বানায়; এর পরে মানটি প্রতিটি clock-এ IDR-এ ধরা হয়। Weak pull-up আর pull-down আসলে বড় মানের resistor, সঙ্গে একটি সুইচ; STM32F103-এর datasheet-এ এদের মান সাধারণত প্রায় 40 kΩ (৩০ থেকে ৫০ kΩ-এর মধ্যে; chip-এর সংস্করণের datasheet দেখে নিন)। দুটি সুরক্ষা diode pin-কে VDD-এর চেয়ে বেশি বা VSS-এর চেয়ে কম ভোল্টেজ থেকে কিছুটা বাঁচায়, তবে সীমা খুব ছোট; অংশ ৮-এ বিস্তারিত।

উপমা — দোকানের শাটার আর দড়ি: Push-pull যেন এমন এক কর্মচারী যিনি শাটার জোর করে তোলেনও, জোর করে নামানও। Open-drain-এর কর্মচারী শুধু নামাতে পারেন; শাটার তোলে একটি স্প্রিং (pull-up). কর্মচারী হাত ছেড়ে দিলে স্প্রিং ধীরে শাটার তোলে। আর input-এর pin হলো দোকানের সামনে দাঁড়ানো একজন পাহারাদার, যিনি শুধু দেখেন শাটার ওঠা না নামা; কিন্তু শাটারে কোনো স্প্রিং না থাকলে বাতাসে সেটি মাঝপথে দোলে, আর পাহারাদার একেকবার একেক কথা বলেন। সেই দোলাই floating input.

৩ · Input mode — floating, pull-up, pull-down আর analog

Input pin-এ output-এর দুটি transistor বন্ধ থাকে, তাই pin নিজে কিছু চালায় না, শুধু শোনে। এখন প্রশ্ন, বাইরে থেকে কেউ না চালালে pin কী পড়বে? CMOS input-এর resistance বিশাল (datasheet-এ leakage current মাত্র কয়েক µA বা তারও কম), তাই কোনো কিছুর সঙ্গে না জোড়া pin-এর ভোল্টেজ ঠিক হয় পাশের তারের চার্জ, হাতের স্পর্শ বা ফ্যানের মোটরের শব্দ দিয়ে। একে বলে floating input: pin কখনো 0, কখনো 1 পড়ে, আর মাঝামাঝি ভোল্টেজে input-এর দুটি transistor আংশিক চালু থেকে অতিরিক্ত current-ও টানতে পারে। STM32F103-এ reset-এর পরে সব সাধারণ pin ঠিক এই floating input (RM0008 §9.1.1), কারণ chip জানে না বাইরে কী জোড়া; কোনো pin-কে হঠাৎ output বানালে বাইরের কোনো যন্ত্রের সঙ্গে সংঘাত হতে পারত।

সমাধান একটি resistor, যা “কেউ না চালালে” মানটি ঠিক করে দেয়। Pull-up resistor pin-কে VDD-তে বাঁধে, তাই বিশ্রামে 1; pull-down VSS-এ বাঁধে, বিশ্রামে 0. বোতাম তখন resistor-এর উল্টো দিকে বসে: pull-up-এর সঙ্গে বোতাম GND-তে, চাপলে 0; pull-down-এর সঙ্গে বোতাম VDD-তে, চাপলে 1. প্রথম ধরনটি active-low, কারণ “সক্রিয়” অবস্থা 0. বাস্তবে active-low বোতাম অনেক বেশি দেখা যায়, তিনটি কারণে: বোতামের একটি পা সরাসরি GND-তে দেওয়া সহজ, প্রায় সব microcontroller-এ internal pull-up আছে (কিছু পুরোনো chip, যেমন ATmega328P-তে শুধু pull-up, pull-down নেই), আর বোতামের লম্বা তারে VDD না নিয়ে GND নেওয়া নিরাপদ, কারণ তার কোথাও chassis-এ ছুঁয়ে গেলে short হয় না।

Input modeভেতরে কী চালুকখনSTM32F103 CNF:MODE
FloatingSchmitt trigger, কোনো pull নয়বাইরের যন্ত্র নিজেই সবসময় 0/1 চালায়, বা বাইরে resistor আছে01:00 = 0x4 (reset)
Pull-upSchmitt + weak pull-upGND-তে বোতাম (active-low), open-drain লাইন10:00 = 0x8, ODR-এর বিট = 1
Pull-downSchmitt + weak pull-downVDD-তে বোতাম (active-high)10:00 = 0x8, ODR-এর বিট = 0
AnalogSchmitt বন্ধ, কোনো pull নয়ADC-র input, অব্যবহৃত pin-এ শক্তি বাঁচানো00:00 = 0x0

STM32F103-এর একটি অদ্ভুত কিন্তু গুরুত্বপূর্ণ নিয়ম লক্ষ করুন: pull-up আর pull-down-এর জন্য CRL-এ একই কোড (CNF = 10), আর কোনটি হবে তা ঠিক করে ODR-এর সেই pin-এর বিট: 1 হলে pull-up, 0 হলে pull-down (RM0008-এর সারণি ২০)। তাই input pin-এ ভুল করে ODR = 0 লিখলে pull-up নিঃশব্দে pull-down হয়ে যায়, আর বোতাম সবসময় “চাপা” পড়ে। নতুন STM32 পরিবারগুলো (F4, G0 ইত্যাদি) এই ঝামেলা এড়াতে আলাদা MODER, OTYPER, OSPEEDR আর PUPDR register রেখেছে; F1-এর ধরন পুরোনো, তবু পরীক্ষায় আর বহু পুরোনো board-এ এটিই বেশি দেখা যায়।

Internal pull-up দুর্বল ইচ্ছে করেই: প্রায় 40 kΩ মানে বোতাম চাপা থাকলে current মাত্র কয়েক দশক µA, ব্যাটারির device-এ যা জরুরি। কিন্তু দুর্বল pull-up শব্দ (noise) বেশি টেনে আনে, আর লম্বা তারে বা কারখানার যন্ত্রের পাশে অনেকে বাইরে 10 kΩ বা 4.7 kΩ দেন। তখন চাপা অবস্থায় current বাড়ে। হিসাবটি অংশ ৮-এর runnable block-এ, আর 5 V-এ একই হিসাব পর্ব ২৩-এ (5 V ÷ 10 kΩ = 0.5 mA).

সাবধান — অব্যবহৃত pin: যে pin কোথাও জোড়া নেই, সেটিকে floating input রেখে দিলে chip কাজ করবে, কিন্তু ভাসমান ভোল্টেজ মাঝামাঝি থাকলে input-এর ভেতরে অল্প অল্প current চলতে পারে আর শব্দে বারবার অবস্থা বদলে শক্তি খরচ হয়। ST-এর low-power-এর পরামর্শ অনুযায়ী অব্যবহৃত pin analog mode-এ রাখা হয়, বা pull দিয়ে একটি নির্দিষ্ট মানে। Low-power নকশা পর্ব ৬০-এ, ব্যাটারির হিসাব পর্ব ৬২-এ।

৪ · Output mode — push-pull, open-drain, গতি আর alternate function

Push-pull output-এ ODR-এর বিট 1 হলে P-MOS চালু, pin VDD-তে (3.3 V); 0 হলে N-MOS চালু, pin VSS-এ (0 V). দুই দিকেই pin জোর দিয়ে চালায়: LED-এর জন্য current দিতে (source) পারে, নিতেও (sink) পারে (current sink আর source). LED, buzzer-এর driver, অন্য chip-এর input, এগুলোর জন্য push-pull স্বাভাবিক পছন্দ। বাজারঘর board-এর PA5-এর LED এভাবেই চালানো, আর 1 হলে জ্বলে।

Open-drain output-এ P-MOS কখনো চালু হয় না। ODR = 0 হলে N-MOS pin-কে মাটিতে টানে; ODR = 1 হলে দুটি transistor বন্ধ, pin ভেসে থাকে (tri-state), আর 1 আসে বাইরের বা ভেতরের pull-up থেকে। RM0008-এর ভাষায়, open-drain-এ ODR-এর “0” N-MOS চালু করে, আর “1” port-কে Hi-Z রাখে (§9.1.8). এতে কী লাভ? তিনটি:

  1. এক তারে অনেকে: কয়েকটি open-drain pin এক তারে জুড়লে কেউ একজন 0 টানলেই তার 0, সবাই ছেড়ে দিলে pull-up দিয়ে 1. এটি wired-AND; কখনো short হয় না, কারণ কেউ 1-এর দিকে জোর দেয় না। I2C-র SDA আর SCL ঠিক এই নীতিতে চলে (পর্ব ৫১)।
  2. অন্য ভোল্টেজে কথা: pull-up-টি 3.3 V-এর বদলে অন্য একটি নিরাপদ ভোল্টেজে দিলে লাইনের 1-এর মান সেই ভোল্টেজ; তবে pin-টি সেই ভোল্টেজ সহ্য করতে পারে কি না, তা datasheet-এ দেখতে হবে (অংশ ৮)।
  3. Interrupt-এর লাইন ভাগাভাগি: অনেক sensor-এর “alert” output open-drain, যাতে কয়েকটি sensor একটি তারে microcontroller-কে ডাকতে পারে।

দাম কোথায়? 1-এ ওঠার কাজ করে resistor, transistor নয়। Resistor আর তারের capacitance মিলে একটি RC: 4.7 kΩ আর 100 pF-এ সময়-ধ্রুবক 470 ns, 70% পর্যন্ত উঠতে প্রায় 566 ns (নিচের block-এ হিসাব)। দুর্বল internal pull-up (40 kΩ-এর আশেপাশে) দিলে এই সময় প্রায় দশগুণ, তাই দ্রুত bus-এ বাইরে শক্ত pull-up লাগে। এই দুটি ধরন নিচে একটি ছোট মডেলে চালিয়ে দেখুন: প্রতিটি driver বলে “0”, “1” বা “Z” (ছেড়ে দেওয়া), আর তারটির ফল কী।

# একটি তারে কয়েকটি pin: প্রতিটি driver বলে "0", "1" বা "Z" (ছেড়ে দেওয়া)
def push_pull(bit):  return "1" if bit else "0"     # P-MOS বা N-MOS, একটি চালু
def open_drain(bit): return "Z" if bit else "0"     # শুধু N-MOS: 0 টানে, 1 মানে ছাড়া

def line(drivers, pull=None):
    d = set(drivers)
    if "0" in d and "1" in d:
        return "SHORT!"                  # একজন VDD-তে, একজন GND-তে টানছে
    if "0" in d: return "0"
    if "1" in d: return "1"
    return pull if pull else "float?"     # কেউ চালাচ্ছে না: pull-up/down বা ভাসমান

print("open-drain, 4.7 kOhm pull-up (wired-AND):")
print(" A B C  line")
for a, b, c in [(1, 1, 1), (0, 1, 1), (1, 0, 1), (1, 1, 0), (0, 0, 0)]:
    ln = line([open_drain(a), open_drain(b), open_drain(c)], pull="1")
    print(f" {a} {b} {c}  {ln}     AND = {a & b & c}")
print("push-pull on the same wire:")
for a, b in [(1, 1), (0, 0), (1, 0)]:
    print(f" A={a} B={b}  line = {line([push_pull(a), push_pull(b)])}")
print("no driver, no pull:", line(["Z", "Z"]))

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

open-drain, 4.7 kOhm pull-up (wired-AND):
 A B C  line
 1 1 1  1     AND = 1
 0 1 1  0     AND = 0
 1 0 1  0     AND = 0
 1 1 0  0     AND = 0
 0 0 0  0     AND = 0
push-pull on the same wire:
 A=1 B=1  line = 1
 A=0 B=0  line = 0
 A=1 B=0  line = SHORT!
no driver, no pull: float?

Open-drain-এর প্রতিটি সারিতে তারের মান আর তিনটি বিটের AND হুবহু এক: এটিই wired-AND. Push-pull-এর শেষ সারিতে A pin-কে VDD-তে আর B GND-তে টানছে; আসল circuit-এ তখন দুটি transistor-এর মধ্য দিয়ে সরাসরি VDD থেকে GND-তে বড় current চলে, যা pin নষ্ট করতে পারে। মডেলটি শুধু যুক্তি দেখায়, ভোল্টেজ বা current নয়। শেষ লাইন মনে করিয়ে দেয়: open-drain লাইনে pull-up না দিলে সবাই ছেড়ে দেওয়ার পরে তার ভাসমান।

Cold room-এর “দরজা খোলা” লাইন (4.7 kΩ pull-up, 3.3 V)
A (দরজা ১)
B (দরজা ২)
C (MCU)
তার
current
  1. সবাই ছেড়ে দিয়েছে। A আর B দুজনেই open-drain, ODR = 1, তাই দুজনেই Hi-Z (Z). Pull-up তারকে 1-এ রাখে; MCU-র input পড়ে 1 = সব দরজা বন্ধ। Resistor-এ প্রায় কোনো current নেই।
  2. দরজা ১ খুলল। A-এর ODR = 0: N-MOS চালু, তার 0. Pull-up দিয়ে চলে 3.3 V ÷ 4.7 kΩ ≈ 0.70 mA, যা A-এর pin নিজের ভেতরে টেনে নেয় (sink). B-এর কিছু করার দরকার নেই।
  3. দরজা ২ খুলল, দরজা ১ বন্ধ। শুধু B টানছে, তার তবু 0. কোন দরজা, তা এই এক তার থেকে জানা যায় না; জানাটা দরকার হলে আলাদা তার বা I2C-র মতো ঠিকানা লাগে।
  4. দুটোই খোলা। A আর B একসাথে 0 টানছে: কোনো সংঘাত নেই, কারণ দুজনেই একই দিকে টানছে। Pull-up-এর 0.70 mA দুটি N-MOS ভাগ করে নেয়।
  5. দুটোই বন্ধ। দুজনেই ছেড়ে দিল; তার আবার 1, কিন্তু ওঠে resistor-এর গতিতে: 4.7 kΩ আর 100 pF-এ ৭০% পর্যন্ত প্রায় 566 ns. নামা দ্রুত (transistor টানে), ওঠা ধীর (resistor টানে)।
  6. ভুল নকশা: push-pull. কেউ A-কে push-pull বানাল। A 1 চালাচ্ছে, B 0: VDD থেকে A-এর P-MOS, তার, B-এর N-MOS হয়ে সরাসরি GND. Current-এর সীমা শুধু transistor-এর ভেতরের resistance; pin গরম হয়ে নষ্ট হতে পারে। শেয়ার করা তারে push-pull নয়।

Output-এর গতি আর drive

STM32F103-এর output-এর MODE বিট শুধু “output” বলে না, সর্বোচ্চ গতিও বলে: 01 = 10 MHz, 10 = 2 MHz, 11 = 50 MHz (RM0008 §9.2.1). নামটি বিভ্রান্তিকর: এটি clock নয়, বরং output-এর ধার কত খাড়া, অর্থাৎ 0 থেকে 1-এ কত দ্রুত ওঠে (slew rate). খাড়া ধার দ্রুত সংকেতের জন্য দরকার, যেমন দ্রুত SPI-এর clock. কিন্তু খাড়া ধার মানে হঠাৎ current-এর ঝাঁকি, তারে প্রতিফলন (ringing) আর বেশি electromagnetic শব্দ, যা পাশের analog অংশ, যেমন smart scale-এর load cell-এর amplifier, বিরক্ত করে। নিয়ম: যতটুকু দরকার, তার চেয়ে বেশি গতি নয়। একটি LED বা alarm-এর জন্য 2 MHz যথেষ্ট।

Drive মানে pin কতটা current দিতে বা নিতে পারে। STM32F103-এর datasheet প্রতিটি সাধারণ pin-কে ±8 mA-তে পূর্ণ মানের logic level দেওয়ার কথা বলে, ঢিলে ভোল্টেজ-সীমায় ±20 mA পর্যন্ত; absolute maximum প্রতি pin 25 mA, আর পুরো chip-এর VDD বা VSS দিয়ে মোট 150 mA (সংস্করণভেদে মিলিয়ে নিন)। Absolute maximum মানে “এর বেশি হলে ক্ষতি হতে পারে”, চালানোর মান নয়। তাই একটি LED-এ ৫ mA-এর আশেপাশে রাখা ভালো অভ্যাস, আর motor, relay বা বড় buzzer কখনো সরাসরি pin থেকে নয়: মাঝে একটি transistor বা driver chip (পর্ব ৬৭)। LED-এর current-limiting resistor-এর সূত্র R = (VDD − Vf) ÷ I; 5 V আর latch-এর হিসাব পর্ব ২৩-এ, 3.3 V-এর হিসাব অংশ ৮-এ।

Alternate function — pin অন্যের হাতে

UART, SPI, I2C বা timer-এর PWM-এর সংকেত chip-এর ভেতরের peripheral তৈরি করে, কিন্তু বাইরে যেতে হয় কোনো একটি pin দিয়ে। Alternate function mode-এ pin-এর output driver ODR-এর বদলে সেই peripheral-এর সংকেত দিয়ে চলে। STM32F103-এ এর জন্য CNF = 10 (AF push-pull) বা 11 (AF open-drain); যেমন USART1-এর TX সাধারণত PA9-এ, AF push-pull. I2C-র pin AF open-drain, ঠিক ওপরের wired-AND-এর কারণে। Input-এর দিকে আলাদা AF mode নেই: UART-এর RX-এর মতো input-এর জন্য pin-টিকে সাধারণ floating বা pull-up input রাখলেই peripheral পড়তে পারে। কোন peripheral কোন pin পায় তা datasheet-এর pin-এর সারণিতে লেখা, আর F1-এ কিছু peripheral AFIO-র remap register দিয়ে অন্য pin-এ সরানো যায়। বাজারঘর board-এর UART-এর কোনো pin নেই, register-এর স্তরেই মডেল করা (Spec decision 24), তাই alternate function শুধু STM32-এর হিসাবেই দেখা হবে।

৫ · STM32F103-এর register — CRL, CRH, IDR, ODR, BSRR আর BRR

এখন সব mode একত্র করে আসল chip-এর register-এ বসানো যাক। STM32F103-এর প্রতিটি port-এ ১৬টি pin; প্রতিটি pin-এর জন্য ৪ বিট: ওপরের দুটি CNF[1:0] (ধরন), নিচের দুটি MODE[1:0] (input, নাকি কোন গতির output). ১৬ × ৪ = ৬৪ বিট একটি ৩২ বিটের register-এ ধরে না, তাই দুটি: CRL (Control Register Low, pin ০–৭, offset 0x00) আর CRH (pin ৮–১৫, offset 0x04). Pin n-এর ৪ বিট CRL-এর বিট 4n+3 থেকে 4n-এ। দুটিরই reset মান 0x44444444: প্রতিটি nibble 0x4 = 0100 = CNF 01, MODE 00 = floating input (RM0008 §9.2.1–9.2.2).

MODE[1:0]CNF[1:0] = 00011011
00 (input)analogfloating (reset)pull-up/pull-down(সংরক্ষিত)
01, 10, 11 (output 10, 2, 50 MHz)GP push-pullGP open-drainAF push-pullAF open-drain

বাকি চারটি register-এর পরিচয় বোর্ডের সারণিতে আগেই দেখেছেন। IDR-এর নিচের ১৬ বিটে ১৬টি pin-এর আসল অবস্থা, শুধু পড়া যায়। ODR-এর নিচের ১৬ বিট output-এর মান, আর input pin-এ pull-এর দিক। BSRR একটি write-only register: নিচের অর্ধেকে 1 লিখলে সেই pin set, ওপরের অর্ধেকে 1 লিখলে reset, 0-এর কোনো প্রভাব নেই; BRR শুধু reset-এর অর্ধেক। এরা কেন আছে আর কীভাবে read-modify-write-এর race থেকে বাঁচায়, তার পুরো গল্প আর board-এ race-এর আসল run পর্ব ৩৫-এ; এখানে আবার করা হবে না। শুধু একটি বাক্য RM0008 থেকে হুবহু মনে রাখুন: “If both BSx and BRx are set, BSx has priority” (§9.2.5), অর্থাৎ ST-এর chip-এ একই বিটে দুটো 1 হলে set জেতে। আর RM0008 GPIO register-গুলোকে ৩২ বিটের word হিসেবেই access করতে বলে, byte বা half-word নয় (§9.1).

একটি জিনিস board-এ নেই, কিন্তু আসল STM32F103-এ বাদ দিলে কিছুই কাজ করে না: port-এর clock. Reset-এর পরে শক্তি বাঁচাতে বেশিরভাগ peripheral-এর clock বন্ধ থাকে (clock gating, পর্ব ৩৩)। GPIOA-র clock চালু হয় RCC-র APB2ENR register (offset 0x18)-এর IOPAEN বিট (বিট ২) 1 করে (RM0008 §7.3.7). এটি ভুলে গেলে CRL-এ লেখা কোথাও পৌঁছায় না, আর LED জ্বলে না, অথচ কোনো error-ও দেখায় না; নতুনদের সবচেয়ে চেনা প্রথম দিনের সমস্যা। কোর্সের board-এ এই ধাপ মডেল করা নেই, RCC-র ওই ঠিকানায় লেখা কেবল উপেক্ষা হয়।

নিচের block একটি পুরো port সাজায়: PA0 বোতাম (pull-up), PA1 ADC-র input (analog), PA5 LED (push-pull, 2 MHz), PA6 alarm (open-drain, 2 MHz), PA9 USART1 TX (AF push-pull, 50 MHz). প্রতিটি pin-এর nibble আর শেষে CRL, CRH আর ODR ছাপে।

# STM32F103 (RM0008 §9.2.1-9.2.2): প্রতি pin-এ ৪ বিট = CNF[1:0] MODE[1:0]
MODE = {"in": 0b00, "10MHz": 0b01, "2MHz": 0b10, "50MHz": 0b11}
CNF_IN = {"analog": 0b00, "floating": 0b01, "pull": 0b10}
CNF_OUT = {"pp": 0b00, "od": 0b01, "af_pp": 0b10, "af_od": 0b11}

def nibble(kind, speed="in"):
    cnf = CNF_IN[kind] if speed == "in" else CNF_OUT[kind]
    return (cnf << 2) | MODE[speed]

def configure(crl, crh, pin, nib):
    reg, pos = (crl, pin) if pin < 8 else (crh, pin - 8)
    shift = 4 * pos
    reg = (reg & ~(0xF << shift)) | (nib << shift)      # RMW: আগে মুছুন, পরে বসান
    return (reg, crh) if pin < 8 else (crl, reg)

crl = crh = 0x44444444                    # reset: সব pin floating input
odr = 0x0000
plan = [(0, "pull", "in", "PA0 button, pull-up"),
        (1, "analog", "in", "PA1 ADC input"),
        (5, "pp", "2MHz", "PA5 LED, push-pull"),
        (6, "od", "2MHz", "PA6 alarm, open-drain"),
        (9, "af_pp", "50MHz", "PA9 USART1 TX (AF)")]
for pin, kind, speed, why in plan:
    nib = nibble(kind, speed)
    crl, crh = configure(crl, crh, pin, nib)
    print(f"PA{pin}: nibble 0x{nib:X} ({nib:04b})  {why}")
odr |= 1 << 0                             # pull-up বাছতে ODR-এর বিট 0 = 1
print(f"CRL = 0x{crl:08X}")
print(f"CRH = 0x{crh:08X}")
print(f"ODR = 0x{odr:04X}  (PA0: 1 = pull-up, 0 = pull-down)")

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

PA0: nibble 0x8 (1000)  PA0 button, pull-up
PA1: nibble 0x0 (0000)  PA1 ADC input
PA5: nibble 0x2 (0010)  PA5 LED, push-pull
PA6: nibble 0x6 (0110)  PA6 alarm, open-drain
PA9: nibble 0xB (1011)  PA9 USART1 TX (AF)
CRL = 0x46244408
CRH = 0x444444B4
ODR = 0x0001  (PA0: 1 = pull-up, 0 = pull-down)

CRL-কে ডান থেকে nibble ধরে পড়ুন: pin ০ = 8 (pull), pin ১ = 0 (analog), pin ২–৪ = 4 (অছোঁয়া floating), pin ৫ = 2 (push-pull 2 MHz), pin ৬ = 6 (open-drain 2 MHz), pin ৭ = 4. CRH-এর ডান থেকে দ্বিতীয় nibble (pin ৯) = B = 1011: CNF 10 (AF push-pull), MODE 11 (50 MHz). configure-এর ভেতরের লাইনটি পর্ব ৩৫-এর field বসানোর নিয়ম: আগে ৪ বিট মুছে তারপর OR. শেষ লাইনে ODR = 0x0001; এটি ভুলে গেলে PA0 pull-down হয়ে যেত।

এখন একটি pin-কে ধাপে ধাপে LED চালানোর জন্য তৈরি করে দেখা যাক, আসল chip আর কোর্সের board পাশাপাশি। STM32-এর মানগুলো ওপরের নিয়মে হিসাব করা (সংখ্যাগুলো Python-এ যাচাই করা); board-এর ঘটনার সময় আমার lab-এর আসল run থেকে (অংশ ৬-এর output).

STM32F103-এর register (বাঁয়ে কাজ)
কাজ
APB2ENR
CRL
PA5 mode
ODR
PA5 pin
  1. Reset. CRL = 0x44444444: PA5-এর nibble (বিট ২৩–২০) = 4 = floating input. APB2ENR = 0, port A-র clock বন্ধ। Pin ভাসমান; বাইরের LED-এর resistor দিয়ে সামান্য leakage ছাড়া কিছু চলে না।
  2. Clock চালু। RCC-র APB2ENR-এর বিট ২ (IOPAEN) = 1, মান 0x00000004. এই ধাপ বাদ দিলে পরের লেখাগুলো port-এ পৌঁছায় না।
  3. Nibble মোছা। 0xFu ≪ 20 = 0x00F00000; উল্টে AND করলে CRL = 0x44044444. এক মুহূর্তের জন্য PA5-এর nibble 0 = analog input; কোনো ক্ষতি নেই, কারণ input-এ pin কিছু চালায় না।
  4. নতুন nibble বসানো। 0x2 = CNF 00 (GP push-pull), MODE 10 (2 MHz): CRL = 0x44244444. এখন pin output, আর ODR-এর বিট ৫ = 0, তাই pin সঙ্গে সঙ্গে 0 V চালায়। আগে ODR ঠিক করে তারপর mode বদলালে pin-এ অনাকাঙ্ক্ষিত একটি ধাক্কা (glitch) এড়ানো যায়।
  5. LED জ্বালানো। BSRR-এ 0x20: ODR = 0x0020, P-MOS চালু, pin 3.3 V, LED জ্বলে। এক store, কোনো পড়া নেই, তাই কোনো interrupt অন্য pin-এর বদল মুছতে পারে না (পর্ব ৩৫)।
  6. Board-এ একই কাজ। Board-এ clock বা nibble নেই: DIR-এ PA5, PA6, PA8-এর বিট 1 (0x0160), তারপর ODR ∣= 0x20. আসল run-এ log-এ 0.1105 ms-এ GPIO PA5 LED ON. সরল মডেলে ধাপ কম, কিন্তু ক্রম একই: আগে দিক, তারপর মান।

৬ · বাজারঘর board-এ আসল run — register ধরে ধরে

এবার তত্ত্ব ছেড়ে board-এ। আমার lab-এর gpio_regs.c firmware প্রতিটি ধাপের পরে UART-এ DIR, ODR আর IDR ছাপে। ধাপগুলো: reset-এর মান; PA5, PA6, PA8 output; ODR-এ RMW দিয়ে LED; BSRR দিয়ে alarm; BRR দিয়ে LED বন্ধ; একই বিটে set আর reset দুটোই; BSRR দিয়ে দুটি pin; ODR-এ একটি byte লেখা; একটি output pin-কে আবার input; আর শেষে write-only BSRR পড়া। মূল অংশ (reference lab-এর bazarghar.h-এর register struct ব্যবহার করে, পর্ব ৩৬):

GPIOA->DIR |= (1u << LED_PIN) | (1u << ALARM_PIN) | (1u << 8);
show("2 DIR PA5,6,8");
GPIOA->ODR |= 1u << LED_PIN;                  show("3 ODR |= PA5 ");
GPIOA->BSRR = 1u << ALARM_PIN;                show("4 BSRR=0x0040");
GPIOA->BRR  = 1u << LED_PIN;                  show("5 BRR =0x0020");
GPIOA->BSRR = (1u << ALARM_PIN) | (1u << (ALARM_PIN + 16u));
show("6 BSRR=0x400040");
GPIOA->BSRR = (1u << LED_PIN) | (1u << 8);   show("7 BSRR=0x0120");
*(volatile uint8_t *)&GPIOA->ODR = (uint8_t)(1u << LED_PIN);
show("8 ODR byte=0x20");
GPIOA->DIR &= ~(1u << LED_PIN);               show("9 DIR clear PA5");
uart_puts("10 read BSRR\r\n");
volatile uint32_t x = *(volatile uint32_t *)&GPIOA->BSRR;
সত্যিকারের run · Clang 22.1.8 (ziglang 0.17.1), Unicorn 2.1.4, বাজারঘর board BG-M3
$ python -B board.py build ../fw/gpio_regs.c -o ../build/gpio_regs.elf
$ python -B board.py run ../build/gpio_regs.elf --cycles 200000
[     0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[     0.0558 ms] UART: 1 reset       DIR=0x0000 ODR=0x0000 IDR=0x0000
[     0.1098 ms] UART: 2 DIR PA5,6,8 DIR=0x0160 ODR=0x0000 IDR=0x0000
[     0.1105 ms] GPIO PA5 LED ON
[     0.1635 ms] UART: 3 ODR |= PA5  DIR=0x0160 ODR=0x0020 IDR=0x0020
[     0.1641 ms] GPIO PA6 ALARM ON
[     0.2171 ms] UART: 4 BSRR=0x0040 DIR=0x0160 ODR=0x0060 IDR=0x0060
[     0.2180 ms] GPIO PA5 LED OFF
[     0.2707 ms] UART: 5 BRR =0x0020 DIR=0x0160 ODR=0x0040 IDR=0x0040
[     0.3259 ms] UART: 6 BSRR=0x400040 DIR=0x0160 ODR=0x0040 IDR=0x0040
[     0.3265 ms] GPIO PA5 LED ON
[     0.3265 ms] GPIO PA8 = 1
[     0.3795 ms] UART: 7 BSRR=0x0120 DIR=0x0160 ODR=0x0160 IDR=0x0160
[     0.3802 ms] GPIO PA6 ALARM OFF
[     0.3802 ms] GPIO PA8 = 0
[     0.4345 ms] UART: 8 ODR byte=0x20 DIR=0x0160 ODR=0x0020 IDR=0x0020
[     0.4353 ms] GPIO PA5 LED OFF
[     0.4898 ms] UART: 9 DIR clear PA5 DIR=0x0140 ODR=0x0020 IDR=0x0000
[     0.5015 ms] UART: 10 read BSRR
[     0.5020 ms] bus error: read at unmapped peripheral address 0x40010810
[     0.5020 ms] HardFault: bus error at PC=0x08000116 main+0xB6
[    25.0000 ms] stopped: cycle limit (200000) reached after 200000 cycles

লাইন ধরে পড়লে ছয়টি শিক্ষা বেরোয়।

  1. IDR output-ও দেখায়। ধাপ ৩-এ ODR = 0x0020 আর IDR = 0x0020: output pin-এর অবস্থাও input-এর পথে ফিরে আসে (Spec decision 23; আসল chip-এ Schmitt trigger output mode-এও চালু, ছবি ৪১.১)। আসল hardware-এ এটি একটি দরকারি পরীক্ষা: pin-এ 1 লিখে IDR-এ 0 পেলে বুঝবেন বাইরে কিছু pin-টিকে জোর করে মাটিতে টানছে।
  2. BSRR আর BRR শুধু নিজের বিট ছোঁয়। ধাপ ৪-এ alarm চালু হলো আর LED জ্বলেই রইল (0x0060); ধাপ ৫-এ LED বন্ধ, alarm অক্ষত (0x0040).
  3. Board-এ set জেতে, ST-এর মতোই। ধাপ ৬-এ একই বিট ৬-এ set (0x0040) আর reset (0x400000) দুটোই: ODR = 0x0040, alarm চালু রইল, তাই কোনো GPIO লাইন নেই। Board RM0008 §9.2.5-এর নিয়ম মানে: set-এর অগ্রাধিকার। তবু নিরাপদ নিয়ম: কোনো বিটে কখনো দুটো 1 লিখবেন না; অন্য chip-এ নিয়ম আলাদা হতে পারে, আর লেখাটি থেকে আপনার উদ্দেশ্যও বোঝা যায় না।
  4. ODR-এ byte লেখা বাকি byte মুছে দেয়। ধাপ ৭-এ ODR = 0x0160 (PA8, PA6 আর PA5). ধাপ ৮-এ শুধু নিচের byte-এ 0x20 লিখলাম, কিন্তু ODR হলো 0x0020: board একটি byte-এর লেখাকে পুরো word-এর লেখা হিসেবে মডেল করে, বাকি byte 0 ধরে, তাই PA8 নিভে গেল; PA6-ও নিভল, কারণ 0x20-এ বিট ৬ = 0. আসল STM32F1-এ byte access-ই অনুমোদিত নয়; register-এর type সবসময় uint32_t.
  5. Output বন্ধ করলে ODR থাকে, pin ছাড়ে। ধাপ ৯-এ DIR থেকে PA5 সরালাম: ODR-এ বিট ৫ তখনো 1 (0x0020), কিন্তু IDR-এর বিট ৫ = 0 আর log-এ LED OFF. Board-এ input pin-কে কেউ না চালালে 0 পড়ে; আসল chip-এ সেটি ভাসমান হতো, আর কী পড়বে বলা যেত না।
  6. BSRR পড়া যায় না। ধাপ ১০-এ BSRR পড়তেই bus error, আর Cortex-M-এর HardFault (PC = 0x08000116); firmware-এর default handler অসীম loop-এ, run থেমেছে cycle-এর সীমায় (25 ms = 200000 ÷ 8000). অনেক আসল chip-এ write-only register পড়লে শুধু 0 আসে, কোনো fault নয়; board-এর এই কড়া আচরণ ভুল ধরতে সাহায্য করে। HardFault-এর বিস্তারিত পর্ব ৬১-এ।

Compiler এগুলো কী বানায়, তাও দেখা দরকার, কারণ BSRR-এর সুবিধা assembly-তেই স্পষ্ট। আমার lab-এর gpio_asm.c-এ চারটি ছোট function, clang -S --target=thumbv7m-none-eabi -mcpu=cortex-m3 -O2 (Clang 22.1.8; directive-এর লাইন বাদ):

button_down:        @ return (GPIOA->IDR & 1u) == 0u;
	movw	r0, #2056         @ 0x0808 -> IDR
	movt	r0, #16385        @ 0x4001
	ldr	r0, [r0]
	movs	r1, #1
	bic.w	r0, r1, r0        @ r0 = 1 AND NOT IDR
	bx	lr
led_on:             @ GPIOA->BSRR = 1u << 5;
	movw	r0, #2064         @ 0x0810 -> BSRR
	movt	r0, #16385
	movs	r1, #32
	str	r1, [r0]          @ একটি store, কোনো ldr নেই
	bx	lr
pins_out:           @ GPIOA->DIR |= (1u << 5) | (1u << 6);
	movw	r0, #2048         @ 0x0800 -> DIR
	movt	r0, #16385
	ldr	r1, [r0]
	orr	r1, r1, #96       @ 0x60
	str	r1, [r0]
	bx	lr

Active-low বোতামের পরীক্ষাটি Clang একটি চতুর নির্দেশে করেছে: bic.w r0, r1, r0 মানে 1 AND NOT IDR. IDR-এর বিট ০ = 0 (চাপা) হলে ফল 1, বিট ০ = 1 হলে 0; ওপরের বিটগুলো 1-এর সঙ্গে AND হয়ে মুছে যায়। led_on-এ BSRR-এ লেখা শুধু একটি str; pins_out-এ DIR-এ |= পুরো RMW (ldr, orr, str). Pin-এর দিক সাধারণত startup-এ একবার বদলায়, তাই সেখানে RMW সমস্যা নয়; কিন্তু চলতে চলতে মান বদলানোর কাজ BSRR দিয়ে।

৭ · Active-low বোতাম পড়া — board-এ scripted input

Smart scale-এর tare বোতামটিকে এবার আসল জীবনের মতো active-low ধরা যাক: pull-up দিয়ে বিশ্রামে 1, চাপলে GND-তে 0. কোর্সের board-এর নিজের তারে PA0 active-high (চাপা = 1, Spec decision 23), তাই আমি board বদলাইনি; board-এর script দিয়ে PA0-র ভোল্টেজের মান সরাসরি ঠিক করেছি। Script-এ "button": 1 মানে PA0-র level 1 = pull-up-এ বোতাম ছাড়া, "button": 0 মানে চাপা; board-এর নিজের “button pressed” লেখা লুকিয়ে ("quiet": true) তার জায়গায় একটি note-এ আসল অর্থ লেখা। অর্থাৎ বৈদ্যুতিক তারটি মডেল করা, কিন্তু firmware, register আর সময় সবই আসল run.

GPIOA->DIR = LED_MASK;                     /* PA0 input, PA5 output */
/* SysTick: প্রতি 1 ms-এ একটি interrupt, CPU মাঝে WFI-তে ঘুমায় */
uint32_t was = 0, presses = 0, last_idr = 0xFFFFu;
while (ms_ticks < 600u) {
    uint32_t idr = GPIOA->IDR;
    uint32_t now = (idr & BTN_MASK) == 0u;  /* active-low: 0 = pressed */
    if (idr != last_idr) { /* t আর IDR ছাপা */ last_idr = idr; }
    if (now && !was) {                      /* নতুন চাপ: ধার (edge) */
        presses++;
        GPIOA->BSRR = LED_MASK;            /* LED on, one store */
    } else if (!now && was) {
        GPIOA->BRR = LED_MASK;             /* LED off */
    }
    was = now;
    __WFI();                               /* পরের 1 ms tick পর্যন্ত ঘুম */
}
সত্যিকারের run · Clang 22.1.8 (ziglang 0.17.1), Unicorn 2.1.4, বাজারঘর board BG-M3
$ python -B board.py run ../build/btn_low.elf --script ../fw/btn_low.json
[     0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[     0.0000 ms] > PA0 = 1 (pull-up, button released)
[     0.0318 ms] UART: t=0 ms IDR=0x0001
[   120.0000 ms] > PA0 = 0 (button pressed to GND)
[   120.0359 ms] UART: t=120 ms IDR=0x0000
[   120.0370 ms] GPIO PA5 LED ON
[   120.0504 ms] UART: press 1
[   121.0359 ms] UART: t=121 ms IDR=0x0020
[   300.0000 ms] > PA0 = 1 (released)
[   300.0359 ms] UART: t=300 ms IDR=0x0021
[   300.0375 ms] GPIO PA5 LED OFF
[   300.0453 ms] UART: release
[   301.0359 ms] UART: t=301 ms IDR=0x0001
[   450.0000 ms] > PA0 = 0 (pressed)
[   450.0359 ms] UART: t=450 ms IDR=0x0000
[   450.0370 ms] GPIO PA5 LED ON
[   450.0504 ms] UART: press 2
[   451.0359 ms] UART: t=451 ms IDR=0x0020
[   520.0000 ms] > PA0 = 1 (released)
[   520.0359 ms] UART: t=520 ms IDR=0x0021
[   520.0375 ms] GPIO PA5 LED OFF
[   520.0453 ms] UART: release
[   521.0359 ms] UART: t=521 ms IDR=0x0001
[   600.0222 ms] UART: presses = 2
[   600.0231 ms] exit(0) after 4800185 cycles
PA0, IDR আর firmware-এর অবস্থা (আসল run)
সময়
PA0 level
IDR
now / was
কাজ
  1. বিশ্রাম। Pull-up PA0-কে 1-এ রাখে, তাই IDR = 0x0001. now = (0x0001 & 1) == 0 = 0: বোতাম চাপা নয়। Active-low-এ “1 মানে ছাড়া”, প্রথমবার উল্টো মনে হয়।
  2. চাপ। 120 ms-এ PA0 = 0. পরের poll-এ (120.0359 ms) IDR = 0x0000, now = 1, আর was = 0: এটি একটি নতুন চাপ, একটি ধার (edge). presses = 1.
  3. LED জ্বলে। BSRR-এ 0x0020; log-এ 120.0370 ms-এ GPIO PA5 LED ON. চাপ থেকে LED পর্যন্ত মোট 0.037 ms, কারণ SysTick-এর 1 ms-এর tick আর চাপ একই মুহূর্তে পড়েছে; সাধারণভাবে polling-এ দেরি এক poll-এর সময় পর্যন্ত, এখানে 1 ms.
  4. এখনো চাপা। 121 ms-এর poll-এ IDR = 0x0020: বিট ০ এখনো 0, কিন্তু বিট ৫ = 1, কারণ LED-এর output-ও IDR-এ দেখা যায়। now = 1, was = 1: পুরোনো চাপ, তাই কিছু নয়। একটি চাপ একবারই গোনা হলো।
  5. ছাড়া। 300 ms-এ PA0 = 1; IDR = 0x0021 (বোতাম আর LED দুটোই)। now = 0, was = 1: BRR-এ 0x0020, 300.0375 ms-এ LED OFF. পরের poll-এ IDR = 0x0001.
  6. দ্বিতীয় চাপ আর শেষ। 450–520 ms একই গল্প। 600 ms-এ presses = 2, তারপর exit(0) after 4800185 cycles, অর্থাৎ 4800185 ÷ 8 MHz ≈ 600 ms. বেশিরভাগ সময় CPU WFI-তে ঘুমিয়ে ছিল।

এই run-এ বোতামটি “পরিষ্কার”: প্রতিটি চাপে একবারই 1 থেকে 0. আসল যান্ত্রিক বোতাম চাপার মুহূর্তে কয়েক ms ধরে কয়েকবার লাফায় (bounce); তখন এই সরল কোড একটি চাপকে কয়েকটি গুনত। তার সমাধান, অর্থাৎ debouncing, পরের পর্ব ৪২ (Button debouncing)-এর বিষয়, সেখানে board-এর লাফানো বোতামের run-ও আছে। আর প্রতি ms-এ জেগে IDR না পড়ে বোতামের ধারে সরাসরি একটি interrupt আনার কথা (EXTI) পর্ব ৪৩ (Interrupt আর ISR নকশা)-এ।

৮ · বৈদ্যুতিক হিসাব আর input-এর সুরক্ষা

Firmware ঠিক থাকলেও pin পুড়তে পারে, আর তখন কোনো debugger কিছু দেখাবে না। তাই GPIO-র কাজের সঙ্গে চারটি হিসাব অভ্যাস করে নিন। নিচের block একসাথে চারটি করে: 3.3 V-এ সবুজ LED-এর resistor, বোতাম চাপা থাকলে pull-up-এর current, open-drain লাইনের ওঠার সময়, আর কয়েকটি LED-এর মোট current. LED-এর Vf 2.0 V একটি ধরে নেওয়া মান; আপনার LED-এর datasheet দেখে বদলে নিন।

import math
VDD = 3.3                                  # volt
E12 = [100, 120, 150, 180, 220, 270, 330, 390, 470, 560, 680, 820]

# ১. LED-এর resistor: R = (VDD - Vf) / I
vf, i_want = 2.0, 0.005                    # ধরা যাক সবুজ LED 2.0 V, লক্ষ্য 5 mA
r_calc = (VDD - vf) / i_want
r_std = next(r for r in E12 if r >= r_calc)
i_real = (VDD - vf) / r_std
print(f"LED: R = ({VDD} - {vf}) / {i_want} = {r_calc:.0f} Ohm -> E12 {r_std} Ohm, "
      f"I = {i_real * 1000:.2f} mA")

# ২. বোতাম চাপা থাকলে pull-up দিয়ে current
for name, r in [("internal ~40 kOhm", 40e3), ("external 10 kOhm", 10e3)]:
    print(f"pull-up {name}: {VDD / r * 1e6:.1f} uA while pressed")

# ৩. Open-drain লাইনে 0 -> 1 ওঠার সময় (RC চার্জ), 70% VDD পর্যন্ত
for r in (4.7e3, 47e3):
    c = 100e-12                            # তার আর pin মিলে 100 pF ধরা
    tau = r * c
    t70 = -tau * math.log(1 - 0.7)
    print(f"R = {r / 1e3:g} kOhm, C = 100 pF: tau = {tau * 1e9:.0f} ns, "
          f"t(70%) = {t70 * 1e9:.0f} ns")

# ৪. আটটি LED একসাথে: মোট current
print(f"8 LEDs: {8 * i_real * 1000:.1f} mA total")

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

LED: R = (3.3 - 2.0) / 0.005 = 260 Ohm -> E12 270 Ohm, I = 4.81 mA
pull-up internal ~40 kOhm: 82.5 uA while pressed
pull-up external 10 kOhm: 330.0 uA while pressed
R = 4.7 kOhm, C = 100 pF: tau = 470 ns, t(70%) = 566 ns
R = 47 kOhm, C = 100 pF: tau = 4700 ns, t(70%) = 5659 ns
8 LEDs: 38.5 mA total
  1. LED: (3.3 V − 2.0 V) ÷ 5 mA = 260 Ω; E12 সারির পরের বড় মান 270 Ω নিলে current 4.81 mA, ±8 mA-এর আরামদায়ক সীমার ভেতরে। ছোট মান (যেমন 220 Ω) নিলে current বাড়ে, তাই সবসময় ওপরের দিকে গোল করুন।
  2. Pull-up: চাপা অবস্থায় পুরো 3.3 V resistor-এ পড়ে। 40 kΩ-এ 82.5 µA, 10 kΩ-এ 330 µA. ব্যাটারির device-এ বোতাম অনেকক্ষণ চাপা থাকতে পারলে এই পার্থক্য গোনার মতো।
  3. ওঠার সময়: t = −RC × ln(1 − 0.7) ≈ 1.204 RC. 4.7 kΩ-এ 566 ns, দশগুণ resistor-এ দশগুণ সময়। 70% একটি সাধারণ CMOS-এর “নিশ্চিত 1”-এর সীমার উদাহরণ; আসল সীমা chip-এর datasheet-এর VIH.
  4. আটটি LED একসাথে 38.5 mA: প্রতিটি pin-এর সীমার ভেতরে, আর STM32F103-এর পুরো chip-এর 150 mA-র সীমারও অনেক নিচে; কিন্তু chip নিজেও current খায়, তাই মোট বাজেট সবসময় যোগ করে দেখুন।

Input-এর সুরক্ষা — diode, resistor আর 5 V

ছবি ৪১.১-এর দুটি protection diode pin-কে VDD-এর একটু ওপরে আর VSS-এর একটু নিচে আটকে রাখে, যাতে স্থির বিদ্যুতের (ESD) ঝটকা বা ছোট overshoot ভেতরের পাতলা gate ভেঙে না দেয়। কিন্তু এগুলো ছোট; এদের ভরসায় বড় ভোল্টেজ লাগানো যায় না। STM32-এর datasheet-এ “injected current”-এর আলাদা সীমা থাকে, কয়েক mA-এর ঘরে; বেশি হলে chip-এর আচরণ অনিশ্চিত, আর বড় হলে স্থায়ী ক্ষতি। তাই বাইরের জগৎ থেকে আসা সংকেতে, বিশেষ করে লম্বা তারে, তিনটি অভ্যাস:

  1. Series resistor: pin আর বাইরের তারের মাঝে 1 kΩ-এর আশেপাশের একটি resistor রাখলে ভুলে ভোল্টেজ বেশি এলেও diode দিয়ে current সীমিত থাকে; আর ভুলে দুটি output মুখোমুখি হলে short-এর current-ও কমে।
  2. 5 V-এর সংকেত: 3.3 V-এর chip-এর সব pin 5 V সহ্য করে না। STM32F103-এর অনেক pin-এর নামের পাশে datasheet-এ “FT” লেখা (5 V tolerant), কিন্তু ADC-র সঙ্গে ভাগ করা pin সাধারণত নয়; প্রতিটি pin আলাদা করে datasheet-এর pin-এর সারণিতে দেখুন। FT pin-ও শুধু input বা open-drain হিসেবে 5 V-এর লাইনে; push-pull output 3.3 V-ই দেবে।
  3. বিপজ্জনক কিছু সরাসরি নয়: mains (২২০ V)-এর কোনো কিছু কখনো সরাসরি GPIO-তে নয়, আর এমন circuit-এ নিজে কাজ করবেন না; বিচ্ছিন্ন (isolated) module বা optocoupler আর প্রশিক্ষিত মানুষের দরকার। Relay, motor বা Li-ion ব্যাটারির charger-এর মতো জিনিসও আলাদা driver আর সুরক্ষা ছাড়া নয় (পর্ব ৬৭)।

আরও গভীরে: STM32F1-এর একটি অদ্ভুত বৈশিষ্ট্য LCKR (offset 0x18): একটি নির্দিষ্ট ক্রমে (LCKK বিটে 1, 0, 1 লিখে, তারপর দুবার পড়ে) লিখলে বাছাই করা pin-এর CRL/CRH-এর সাজানো পরের reset পর্যন্ত আর বদলানো যায় না (RM0008 §9.2.7); ভুল কোড বা বিগড়ে যাওয়া pointer যাতে নিরাপত্তার কোনো pin-এর mode বদলাতে না পারে। আর pin-এর ভেতরের সুরক্ষা diode-গুলোর একটি অবাঞ্ছিত দিক আছে: কোনো pin-এ বাইরে থেকে ভোল্টেজ আসছে কিন্তু chip-এর VDD বন্ধ, তখন diode দিয়ে current VDD-তে ঢুকে পুরো chip-কে আধা-চালু করে দিতে পারে (phantom powering). 5 V-tolerant pin-এর গঠন আলাদা (RM0008-এর চিত্রে এদের জন্য আলাদা VDD_FT), যাতে এই পথ কম থাকে; তবু নকশায় power ক্রম আর এই পথ মাথায় রাখতে হয়।

পরীক্ষা ও ইন্টারভিউতে: (১) “Push-pull আর open-drain-এর পার্থক্য?” → push-pull 0 আর 1 দুটোই চালায়; open-drain শুধু 0, 1 আসে pull-up থেকে, তাই এক তারে অনেকজন (wired-AND). (২) “Input কেন floating রাখা উচিত নয়?” → মান অনিশ্চিত, শব্দ ধরে, মাঝামাঝি ভোল্টেজে বাড়তি current. (৩) “STM32F103-এ PA5-কে 2 MHz push-pull output বানাতে CRL-এর কোন বিটে কী?” → বিট ২৩–২০-এ 0x2 (CNF 00, MODE 10). (৪) “STM32F1-এ pull-up আর pull-down কীভাবে বাছেন?” → CNF = 10, আর ODR-এর সেই বিট 1 = pull-up, 0 = pull-down. (৫) “BSRR কেন, আর একই বিটে set আর reset দুটো 1 হলে?” → এক store-এ atomic বদল; ST-এর নিয়মে (আর কোর্সের board-এও) set জেতে; তবু দুটো একসাথে না লেখাই নিরাপদ।

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

“STM32-এ LED blink-এর কোড দিন” লিখলে AI assistant কয়েক সেকেন্ডে কোড দেয়, আর অনেক সময় চলে। কিন্তু GPIO-র ভুল প্রায়ই compile-এ ধরা পড়ে না: ভুল পরিবারের register, ভুলে যাওয়া clock, বা এমন বৈদ্যুতিক পরামর্শ যা pin পোড়াতে পারে। সবচেয়ে চেনা ভুল আর ধরার উপায়:

AI প্রায়ই যা করেকীভাবে ধরবেন
STM32F1-এর কোডে F4-এর MODER/PUPDR বা উল্টোটা লেখে; ঠিকানা আর বিট বানিয়ে বলেনির্দিষ্ট chip-এর reference manual (F1-এর জন্য RM0008) আর vendor-এর header মিলিয়ে দেখুন
RCC-তে port-এর clock চালু করতে ভুলে যায়Startup-এর তালিকায় clock-এর ধাপ আছে কি না দেখুন; debugger-এ register পড়ে 0 পেলে প্রথম সন্দেহ
Pull-up চায়, কিন্তু F1-এ ODR-এর বিট 1 করতে ভোলে, বা ODR = … দিয়ে পরে মুছে দেয়Input pin-এর জন্য ODR-এর বিট আলাদা করে পরীক্ষা করুন; IDR পড়ে বিশ্রামের মান মিলিয়ে নিন
Active-low বোতামে “চাপা = 1” ধরে লেখেCircuit দেখে চাপা অবস্থার level ঠিক করুন; board বা simulator-এ চাপা আর ছাড়া দুই অবস্থার IDR ছাপুন
শেয়ার করা তার বা I2C-তে push-pull দেয়; LED সরাসরি pin-এ, resistor ছাড়াOpen-drain আর pull-up আছে কি না দেখুন; R = (VDD − Vf) ÷ I নিজে হিসাব করুন
BSRR পড়ে RMW করে, বা একই বিটে set আর reset দুটোই লেখেClang-এর -S-এ BSRR-এর ঠিকানায় ldr খুঁজুন; set আর reset-এর mask-এর AND শূন্য কি না দেখুন

AI-কে কাজে লাগাতে chip, register আর circuit শুরুতেই স্পষ্ট বলুন, আর যাচাইয়ের শর্ত দিন:

আমি STM32F103-এর জন্য bare-metal C লিখছি (CMSIS header, HAL ছাড়া)। Reference manual RM0008. ১. PA5-এ সবুজ LED (270 ওহম দিয়ে GND-তে) আর PA0-তে GND-এর দিকে একটি বোতাম আছে। RCC-তে GPIOA-র clock চালু করে PA5-কে 2 MHz push-pull output আর PA0-কে internal pull-up-সহ input বানানোর কোড দাও। CRL-এর প্রতিটি nibble-এর মান binary-তে ব্যাখ্যা করবে। ২. বোতাম active-low ধরে প্রতি 1 ms-এ poll করে প্রতিটি নতুন চাপে LED toggle করার কোড দাও; LED বদলাবে শুধু BSRR দিয়ে, BSRR কখনো পড়বে না। ৩. তোমার কোডে কোন লাইনে RMW আছে, আর কেন সেখানে তা নিরাপদ, বলো। ৪. কোনো register-এর নাম, ঠিকানা বা বিট নিয়ে নিশ্চিত না হলে "নিশ্চিত নই, RM0008 দেখুন" লিখবে; F4-এর MODER বা PUPDR ব্যবহার করবে না।

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

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

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

প্র ০১Reset-এর পরে প্রায় সব microcontroller pin-কে output না বানিয়ে floating বা high-impedance input রাখে কেন? এর দাম কী, আর নকশাকার এই দাম কীভাবে সামলান?

Reset-এর মুহূর্তে chip-এর কোনো ধারণা নেই pin-এর বাইরে কী বসানো। একটি pin হয়তো অন্য একটি chip-এর output-এর সঙ্গে জোড়া, হয়তো একটি motor driver-এর enable, হয়তো সরাসরি GND-তে। Chip যদি reset-এর পরে সব pin-কে, ধরা যাক, push-pull 0 বানাত, তাহলে যে pin-এ বাইরে থেকে কেউ 1 চালাচ্ছে সেখানে সঙ্গে সঙ্গে short হতো। আর 1 বানালে কোনো motor বা heater-এর enable হঠাৎ চালু হয়ে যেত। তাই সবচেয়ে নিরীহ অবস্থা বেছে নেওয়া হয়: কিছু না চালানো, শুধু শোনা। STM32F103-এর RM0008 স্পষ্ট বলে, reset-এর সময় আর ঠিক পরে alternate function বন্ধ আর I/O port floating input (§9.1.1); কেবল debug-এর JTAG pin-গুলো pull-up বা pull-down-সহ input, যাতে debugger সংযোগ পায়। পুরোনো 8255-এর নকশাও একই যুক্তিতে চলেছিল: reset-এর পরে তার তিনটি port input (পর্ব ২৪)।

দাম হলো ভাসমান সময়। Power চালু হওয়া থেকে firmware যতক্ষণ না pin সাজায়, ততক্ষণ pin-এর মান অনিশ্চিত। এই সময় কয়েক µs থেকে কয়েক ms পর্যন্ত হতে পারে, কারণ আগে clock স্থির হয়, startup কোড চলে, তারপর main-এ GPIO সাজানো হয় (পর্ব ৩২)। এর মধ্যে একটি MOSFET-এর gate ভাসমান থাকলে motor একটু ঝাঁকুনি দিতে পারে, একটি relay ক্লিক করতে পারে, একটি LED মৃদু জ্বলতে পারে। বাস্তব নকশায় তাই গুরুত্বপূর্ণ সংকেতে বাইরে একটি resistor থাকে, যা “নিরাপদ” অবস্থা নিশ্চিত করে: motor-এর enable-এ pull-down, active-low reset লাইনে pull-up. এই resistor firmware-এর ওপর নির্ভর করে না, power আসার প্রথম মুহূর্তেই কাজ করে।

দ্বিতীয় অভ্যাস firmware-এ: mode বদলানোর আগে ODR-এ ঠিক মান লেখা। অংশ ৫-এর stepper-এ দেখা গেছে, CRL-এ output বসানোর সঙ্গে সঙ্গে pin ODR-এর মান চালাতে শুরু করে; ODR আগে ঠিক থাকলে কোনো ক্ষণিক ভুল ধাক্কা আসে না। তৃতীয়ত, কিছু নিরাপত্তার pin-এর জন্য STM32F1-এর LCKR দিয়ে সাজানো তালাবদ্ধ করা যায়। এই সব মিলেই শিল্প-যন্ত্রে নিয়ম দাঁড়িয়েছে: hardware নিরাপদ অবস্থা দেয়, firmware তা থেকে সাবধানে বেরোয়।

মূল উপলব্ধি: Reset-এর পরে input-ই নিরাপদ, কারণ কিছু না চালালে কারও সঙ্গে সংঘাত হয় না; কিন্তু ভাসমান সময়ের দায় নকশাকারের, যা বাইরের pull resistor আর “আগে ODR, পরে mode” অভ্যাস দিয়ে মেটাতে হয়।

প্র ০২Open-collector আর open-drain-এর ধারণা TTL-এর যুগ থেকে আজকের I2C পর্যন্ত টিকে আছে। একটি “শুধু 0 টানতে পারে” এমন output এত কাজের কেন, আর এর সীমা কোথায়?

TTL-এর যুগে, ১৯৬০ আর ১৯৭০-এর দশকে, 7400 পরিবারের অনেক gate-এর output-এ ওপরে-নিচে দুটি transistor থাকত (totem-pole), যা আজকের push-pull-এর পূর্বসূরি। কিন্তু একই পরিবারে open-collector-এর gate-ও ছিল, যেমন 7401 বা 7405-এর মতো অংশ, যাদের ওপরের transistor নেই। কারণ ছিল খুব ব্যবহারিক: কয়েকটি বোর্ড একটি সাধারণ তারে “বিপদ” বা “interrupt” জানাতে চাইত। Totem-pole output এক তারে জুড়লে একজন 1 আর একজন 0 চালালে short হয়; open-collector-এ কেউ 1-এর দিকে জোর দেয় না, তাই যেকোনো সংখ্যক যন্ত্র এক তারে বসতে পারে। একটি pull-up resistor তারকে 1 রাখে, আর যেকোনো একজন টানলে 0. CMOS-এর যুগে একই ধারণার নাম open-drain, কারণ transistor-এর drain বাইরে খোলা।

এই নীতির সবচেয়ে বিখ্যাত বংশধর I2C, যা Philips ১৯৮২ সালের দিকে বানিয়েছিল, প্রচলিত বিবরণ অনুযায়ী টেলিভিশনের মতো যন্ত্রের ভেতরের chip-গুলোকে দুটি তারে জোড়ার জন্য। NXP-র I2C specification (UM10204) SDA আর SCL দুটিকেই open-drain বা open-collector আর pull-up-যুক্ত বলে। এর ফলে তিনটি জিনিস প্রায় বিনা খরচে আসে: ACK, যেখানে receiver শুধু একটি বিটে লাইন টেনে ধরে; arbitration, যেখানে দুজন master একসাথে লিখলে যে 0 লেখে সে জেতে, কারণ wired-AND-এ 0-ই প্রাধান্য পায়; আর clock stretching, যেখানে ধীর slave SCL টেনে ধরে master-কে অপেক্ষা করায়। এগুলোর বিস্তারিত পর্ব ৫১-এ; এখানে লক্ষ করুন, তিনটিই সম্ভব কারণ কেউ জোর করে 1 চালায় না। CAN bus-এর dominant আর recessive বিটের ধারণাও একই পরিবারের, যদিও সেখানে differential তারে (পর্ব ৫২)।

সীমা গতি আর শক্তিতে। 0 থেকে 1-এ ওঠার কাজ resistor করে, তাই RC-এর সময় লাগে; অংশ ৮-এর হিসাবে 4.7 kΩ আর 100 pF-এ ৭০% পর্যন্ত প্রায় 566 ns. দ্রুত চাইলে resistor ছোট করতে হয়, কিন্তু তখন প্রতিবার লাইন 0 থাকার সময় বেশি current resistor দিয়ে মাটিতে যায়, শক্তি নষ্ট হয়, আর প্রতিটি pin-কে সেই current sink করার ক্ষমতা রাখতে হয়। I2C-র specification এই কারণে bus-এর capacitance আর pull-up-এর মানের সীমা বেঁধে দেয়। তাই শুধু যে কাজে “এক তারে অনেকে” বা “অন্য ভোল্টেজে 1” দরকার, সেখানেই open-drain; দ্রুত, এক চালকের সংকেতে push-pull.

মূল উপলব্ধি: শুধু 0 টানার সীমাবদ্ধতাই open-drain-এর শক্তি: কেউ 1 জোর করে না বলে অনেকে এক তার ভাগ করতে পারে, আর সেই ভিত্তিতে I2C-র ACK, arbitration আর clock stretching দাঁড়ায়; দাম হলো resistor-নির্ভর ধীর ওঠা আর বাড়তি current.

প্র ০৩STM32F1 pull-up আর pull-down বাছতে ODR-এর বিট ব্যবহার করে, অথচ পরের STM32 পরিবারগুলো আলাদা MODER, OTYPER, OSPEEDR আর PUPDR register এনেছে। এই নকশা-পরিবর্তনের যুক্তি কী, আর firmware-এর ওপর এর প্রভাব কী?

STM32F1, ২০০৭ সালের দিকে বাজারে আসা ST-এর প্রথম Cortex-M3 পরিবার, প্রতি pin-এ মাত্র ৪ বিট রেখেছিল: CNF আর MODE. এতে input-এর চারটি আর output-এর চারটি ধরন, সঙ্গে তিনটি গতি, সব ধরে যায়, কিন্তু pull-এর দিক রাখার জায়গা থাকে না। সমাধান ছিল ODR-কে দ্বিতীয় অর্থ দেওয়া: input pin-এ ODR-এর বিট pull-এর দিক। Silicon-এর দিক থেকে এটি কম register-এ কাজ সারে, আর hardware-এ যুক্তিসঙ্গত, কারণ input pin-এ ODR-এর বিট এমনিতে অব্যবহৃত।

কিন্তু firmware-এর দিক থেকে এটি একটি ফাঁদ। ধরুন একই port-এ PA0 pull-up বোতাম আর PA5 LED. কেউ LED নেভাতে লিখলেন GPIOA->ODR = 0;, পুরো register-এ শূন্য। LED নিভল, কিন্তু PA0-র pull-up নিঃশব্দে pull-down হয়ে গেল; এখন বোতাম ছাড়া অবস্থাতেও 0 পড়ে, অর্থাৎ firmware ভাবে বোতাম সবসময় চাপা। ভুলটি বোতামের কোডে নয়, LED-এর কোডে, তাই খুঁজে পেতে অনেক সময় লাগে। একই কারণে F1-এ BSRR আরও জরুরি: LED-এর জন্য শুধু BSRR আর BRR ব্যবহার করলে অন্য বিট কখনো ছোঁয়া হয় না। তা ছাড়া CRL/CRH-এ একটি pin-এর mode, ধরন আর গতি একসাথে বাঁধা, তাই একটি জিনিস বদলাতে পুরো nibble-এর RMW লাগে।

পরের পরিবারগুলো, যেমন STM32F4 আর পরে G0, প্রতিটি বৈশিষ্ট্যকে আলাদা register দিয়েছে: MODER-এ প্রতি pin ২ বিট (input, output, AF, analog), OTYPER-এ ১ বিট (push-pull বা open-drain), OSPEEDR-এ গতি, PUPDR-এ pull. সঙ্গে AFRL/AFRH, যেখানে প্রতিটি pin-এ কোন peripheral যাবে তা সরাসরি নম্বর দিয়ে বাছা যায়, F1-এর সীমিত remap-এর বদলে। ফল: একটি বৈশিষ্ট্য বদলাতে শুধু সেই register ছোঁয়া, আর ODR আবার শুধু output-এর মান। Register বেশি, কিন্তু প্রতিটির অর্থ এক।

Firmware-এর ওপর প্রভাব দুই রকম। এক, F1-এর কোড অন্য পরিবারে সরাসরি চলে না, আর উল্টোটাও না; AI assistant বা অনলাইন উদাহরণ প্রায়ই এই দুটি মিশিয়ে ফেলে (অংশ ৯)। দুই, HAL বা LL library এই পার্থক্য লুকিয়ে একই function দেয়, যা সুবিধাজনক, কিন্তু register-এর স্তরে কী ঘটছে না জানলে debug কঠিন। এই কোর্সের board ইচ্ছে করে আরও সরল (শুধু DIR), কিন্তু IDR, ODR, BSRR আর BRR-এর ঠিকানা F1-এর মতো রেখেছে, যাতে শেখা অভ্যাস F1-এ সরাসরি চলে।

মূল উপলব্ধি: একটি register-এ দুটি অর্থ রাখলে silicon বাঁচে কিন্তু firmware-এ লুকোনো নির্ভরতা জন্মায়; নতুন নকশা প্রতিটি বৈশিষ্ট্যকে নিজের register দিয়ে সেই ফাঁদ সরিয়েছে, আর পুরোনো chip-এ কাজের সময় এই পার্থক্য মনে রাখাই নিরাপত্তা।

প্র ০৪Output-এর “গতি” (slew rate) কেন একটি সেটিং, সবসময় সর্বোচ্চ নয়? একটি দ্রুত ধার কোথায় কোথায় সমস্যা করে, আর বাজারঘরের smart scale-এর নকশায় এর অর্থ কী?

প্রথম ধারণায় মনে হয় দ্রুততর সবসময় ভালো। কিন্তু একটি digital ধারের খাড়াভাব মানে খুব কম সময়ে বড় ভোল্টেজ-বদল, আর সেটি করতে হঠাৎ বড় current লাগে: তারের capacitance চার্জ করা, chip-এর ভেতরের power লাইন থেকে টানা। তিনটি ফল আসে। প্রথমত, ground bounce আর power-এর কাঁপুনি: একসাথে অনেক pin খাড়াভাবে বদলালে chip-এর ভেতরের GND কয়েক মুহূর্তের জন্য সরে যায়, আর পাশের input ভুল পড়তে পারে। দ্বিতীয়ত, তারে প্রতিফলন: ধার যত খাড়া, ছোট তারও তত “লম্বা transmission line”-এর মতো আচরণ করে, আর সংকেত কিছুক্ষণ কেঁপে (ringing) স্থির হয়। তৃতীয়ত, electromagnetic শব্দ (EMI): খাড়া ধারে অনেক উচ্চ frequency-এর উপাদান থাকে, যা বাতাসে ছড়ায় আর পাশের যন্ত্রকে বিরক্ত করে; বাণিজ্যিক পণ্যকে এই শব্দের নিয়ম মানতে হয়।

STM32F103-এ তাই MODE বিট দিয়ে তিনটি সর্বোচ্চ গতি: 2, 10 আর 50 MHz. এগুলো clock নয়, output driver-এর শক্তি আর ধারের খাড়াভাবের ধাপ। 50 MHz দরকার শুধু দ্রুত SPI বা বাইরের মেমরির মতো সংকেতে; একটি LED, একটি relay-এর driver বা একটি alarm-এর জন্য 2 MHz-ই যথেষ্ট, কারণ সেই pin হয়তো সেকেন্ডে কয়েকবার বদলায়। নতুন STM32 পরিবারে OSPEEDR একই ধারণা আরও ধাপে দেয়।

বাজারঘরের smart scale-এ এর অর্থ সরাসরি। Load cell থেকে আসা সংকেত খুব ছোট, কয়েক mV-এর ঘরে, যা একটি amplifier বড় করে 12 বিটের ADC-তে দেয় (পর্ব ৪৭ আর ৬৬)। একই board-এ display বা LED-এর pin যদি অকারণে 50 MHz-এ খাড়া ধারে বদলায়, তার শব্দ amplifier-এর input-এ ঢুকে কয়েকটি count-এর কাঁপুনি আনতে পারে, আর README-র calibration অনুযায়ী প্রতি count প্রায় 1.43 g (2000 g ÷ 1400 count); কয়েক count মানে কয়েক গ্রামের অস্থির মাপ। তাই নকশার নিয়ম: analog অংশের কাছের pin সবচেয়ে কম গতিতে, দ্রুত সংকেত দূরে আর ছোট পথে, আর যেখানে সম্ভব সেই সময়ে ADC-র নমুনা না নেওয়া যখন বড় digital বদল হচ্ছে।

মূল উপলব্ধি: Output-এর গতি একটি নকশার সিদ্ধান্ত, বিনামূল্যের সুবিধা নয়: যতটুকু সংকেতের দরকার ততটুকু খাড়া ধার, কারণ বাড়তি খাড়াভাব শব্দ, কাঁপুনি আর analog মাপে ভুল হয়ে ফেরত আসে।

প্র ০৫কোর্সের virtual board-এর GPIO মডেল আসল STM32-এর চেয়ে কোথায় কোথায় আলাদা, আর এমন সরল মডেলে শেখার লাভ ও ঝুঁকি কী? আসল board-এ যাওয়ার আগে কী কী যাচাই করবেন?

পার্থক্যগুলো এই পর্বের run-এই দেখা গেছে। প্রথমত, board-এ mode নেই, শুধু DIR: কোনো pull, গতি, open-drain বা alternate function নেই, আর PA0-র বোতাম বাইরের pull-down-এ বাঁধা ধরা (Spec decision 23). দ্বিতীয়ত, port-এর clock-এর কোনো ধাপ নেই; RCC-র সেই ঠিকানায় লেখা চুপচাপ উপেক্ষা হয়। তৃতীয়ত, ODR-এ byte লেখা board-এ বাকি byte শূন্য করে; আসল STM32F1-এ byte access অনুমোদিতই নয়। চতুর্থত, BSRR পড়লে board-এ bus error আর HardFault, অনেক আসল chip-এ শুধু 0. পঞ্চমত, input pin-কে কেউ না চালালে board-এ IDR 0 পড়ে, আসল chip-এ অনিশ্চিত। আর সবচেয়ে বড় কথা, board-এ ভোল্টেজ, current, সময়ের ধার বা bounce নেই; শুধু 0 আর 1, আর timing-ও আসল Cortex-M3-এর নয় (Spec decision 17: এক নির্দেশ = এক cycle).

লাভ হলো মনোযোগ। নতুন একজন শিক্ষার্থী প্রথম দিনে যদি clock, CNF, MODE, pull আর বৈদ্যুতিক সীমা সব একসাথে সামলান, তবে register আর বিটের মৌলিক ধারণা, অর্থাৎ পড়া, লেখা, set, reset আর IDR-এ output দেখা, চাপা পড়ে যায়। সরল মডেলে প্রতিটি লেখার ফল একটি পরিষ্কার log-এর লাইন, সময়সহ, আর একই run প্রতিবার একই ফল দেয়, তাই ভুল ধরা সহজ। কিছু কড়া আচরণ, যেমন BSRR পড়লে fault, আসলে শিক্ষার পক্ষে: আসল chip-এ যে ভুল চুপচাপ “কাজ করে”, board তা জোরে ধরিয়ে দেয়।

ঝুঁকি হলো ভুল আত্মবিশ্বাস। Board-এ চলা কোড আসল chip-এ clock ছাড়া একেবারেই চলবে না; set-reset-এর নিয়মে নির্ভর করা কোড দুই জায়গায় দুই ফল দেবে; আর board-এ কোনো pin পোড়ে না। তাই আসল board-এ যাওয়ার আগে একটি তালিকা: chip-এর reference manual থেকে প্রতিটি register আর বিট মেলানো; clock চালুর ধাপ; mode বদলের আগে ODR; input-এর pull-এর দিক; প্রতিটি output-এর current আর মোট বাজেট; শেয়ার করা তারে open-drain; 5 V-এর সংকেত কোন pin-এ, আর সেটি FT কি না; আর বোতামের bounce-এর ব্যবস্থা (পর্ব ৪২)। এরপর আসল hardware-এ প্রথমবার চালানোর সময় একটি সীমিত current-এর power supply বা অন্তত একটি multimeter হাতের কাছে রাখা ভালো।

মূল উপলব্ধি: সরল মডেল যুক্তি শেখায়, বিদ্যুৎ নয়; board-এ প্রমাণিত firmware-কে আসল chip-এ নেওয়ার সেতু হলো reference manual, datasheet-এর বৈদ্যুতিক সীমা আর মডেলের প্রতিটি সরলতার সচেতন তালিকা।

অনুশীলন

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

  1. নকশা ও বাস্তবায়ন — STM32F103-এ cold room-এর pin: STM32F103-এ PB12-তে একটি দরজার সুইচ (GND-এর দিকে, internal pull-up চাই), PB13-এ alarm-এর buzzer-এর driver transistor (push-pull, 2 MHz), আর PB7-এ একটি sensor-এর open-drain “alert” লাইন (input, বাইরে 4.7 kΩ pull-up আছে)। Reset-এর মান থেকে শুরু করে CRL আর CRH-এর নতুন মান, ODR-এ কোন বিট লাগবে, আর RCC-র কোন বিট চালু করবেন তা লিখুন; তারপর সাজানোর C function লিখুন।

    Nibble: PB12 pull-up input = CNF 10, MODE 00 = 0x8; PB13 push-pull 2 MHz = CNF 00, MODE 10 = 0x2; PB7 floating input = 0x4 (বাইরে pull-up আছে, তাই internal pull লাগবে না; reset-এর মানই)। PB7 CRL-এর pin ৭, তাই CRL = 0x44444444 অপরিবর্তিত। PB12 আর PB13 CRH-এর pin ৪ আর ৫ (12 − 8, 13 − 8), অর্থাৎ বিট ১৯–১৬ আর ২৩–২০: CRH = 0x44284444. ODR-এর বিট ১২ = 1 (pull-up বাছাই), আর buzzer বন্ধ রাখতে বিট ১৩ = 0, তাই mode বদলের আগে BSRR-এ 0x20001000 (বিট ১২ set, বিট ২৯ = ১৬ + ১৩ reset). Port B-র clock: RCC APB2ENR-এর IOPBEN, বিট ৩ (RM0008 §7.3.7).

    void coldroom_pins_init(void)
    {
        RCC->APB2ENR |= 1u << 3;                   /* IOPBEN */
        GPIOB->BSRR = (1u << 12) | (1u << (13 + 16)); /* pull-up, buzzer off */
        uint32_t crh = GPIOB->CRH;
        crh &= ~((0xFu << 16) | (0xFu << 20));     /* PB12, PB13 nibble মোছা */
        crh |=  (0x8u << 16) | (0x2u << 20);       /* pull input, PP 2 MHz */
        GPIOB->CRH = crh;                          /* PB7: reset-এর floating input */
    }

    যাচাই: অংশ ৫-এর Python মডেলে pin ১২ = ("pull", "in") আর ১৩ = ("pp", "2MHz") চালালে CRH = 0x44284444, CRL অপরিবর্তিত 0x44444444. RCC আর GPIOB-এর নাম CMSIS-ধাঁচের device header-এর; কোর্সের board-এ port B নেই, তাই এটি board-এ চালানো নয়, শুধু হিসাবে যাচাই। দরজার সুইচ active-low: দরজা খোলা মানে (সুইচের ধরন অনুযায়ী) বিট ১২ = 0, আর alert লাইনও active-low হতে পারে, sensor-এর datasheet দেখে ঠিক করুন।

  2. ভুল খুঁজুন — বোতাম “সবসময় চাপা”: STM32F103-এ একজন লিখলেন: RCC->APB2ENR |= 1u << 2; GPIOA->CRL = 0x44244448; GPIOA->ODR = 0; তারপর loop-এ if (GPIOA->IDR & 1u) led_on(); else led_off();, যেখানে PA0-তে GND-এর দিকে একটি বোতাম আর PA5-এ LED. LED সবসময় নেভা থাকে, বোতাম চাপুন বা না চাপুন। দুটি ভুল খুঁজে বের করুন।

    প্রথম ভুল, pull-এর দিক: CRL-এর PA0 nibble = 8 (CNF 10 = pull-up/pull-down) ঠিক, PA5 = 2 (push-pull 2 MHz)-ও ঠিক। কিন্তু ODR = 0 PA0-র বিটও 0 করেছে, তাই pull-up নয়, pull-down চালু (RM0008-এর সারণি ২০)। বোতাম GND-এর দিকে, pull-down-ও GND-এর দিকে: চাপুন বা না চাপুন, PA0 = 0. ঠিক রূপ: GPIOA->BSRR = 1u << 0; (pull-up), তাহলে বিশ্রামে 1, চাপলে 0. দ্বিতীয় ভুল, যুক্তি উল্টো: active-low বোতামে চাপা মানে IDR-এর বিট ০ = 0, কিন্তু কোড বিট = 1-এ LED জ্বালায়। প্রথম ভুলের কারণে বিট সবসময় 0, তাই LED সবসময় নেভা; প্রথম ভুল ঠিক করলেও দ্বিতীয়টির জন্য LED উল্টো আচরণ করত (ছাড়া অবস্থায় জ্বলা)। ঠিক রূপ: if ((GPIOA->IDR & 1u) == 0u) led_on(); else led_off();. Board-এ একই active-low যুক্তি চালিয়ে দেখা গেছে: চাপা অবস্থায় IDR = 0x0000, ছাড়া অবস্থায় 0x0001, আর (idr & 1) == 0 দিয়ে LED সঠিক সময়ে জ্বলেছে-নিভেছে (অংশ ৭)। ছোট আরেকটি কথা: CRL = … সরাসরি লেখায় বাকি pin-গুলোর mode-ও লেখা হয়ে যায়; এখানে বাকিগুলো 4 (reset-এর মান) রাখা হয়েছে, তাই ক্ষতি নেই, কিন্তু অন্য কোড সেগুলো আগে বদলে থাকলে মুছে যেত।

  3. আগে বলুন, তারপর মেলান — board-এর register: বাজারঘর board-এ reset-এর পরে পরপর: (ক) DIR = 0x0060 (খ) ODR = 0x0040 (গ) BSRR = 0x00200020 (ঘ) BRR = 0x0040 (ঙ) DIR = 0x0020. বোতাম ছাড়া (board-এর নিজের তারে PA0 = 0). প্রতিটির পরে ODR আর IDR কত, আর log-এ কোন GPIO লাইন আসবে?

    (ক) DIR = 0x0060, ODR = 0x0000, IDR = 0x0000; কোনো pin বদলায়নি, তাই কোনো GPIO লাইন নেই। (খ) ODR = 0x0040, IDR = 0x0040: GPIO PA6 ALARM ON. (গ) বিট ৫-এ set আর reset দুটোই: board ST-এর নিয়ম মানে, set জেতে: ODR = (0x0040 & ~0x0020) | 0x0020 = 0x0060, IDR = 0x0060: GPIO PA5 LED ON. (ঘ) BRR বিট ৬ মোছে: ODR = 0x0020, IDR = 0x0020, GPIO PA6 ALARM OFF. (ঙ) DIR থেকে PA6 সরল, কিন্তু PA6 আগেই 0 আর PA5 output-ই থাকল, তাই কিছু বদলায় না: ODR = 0x0020, IDR = 0x0020, কোনো লাইন নেই। আমার lab-এ এই পাঁচটি লেখা একটি firmware-এ চালিয়ে প্রতিবার ODR আর IDR ছাপা হয়েছে; ফল হুবহু ওপরের মতো: a 0x0000 0x0000, b 0x0040 0x0040 (সঙ্গে ALARM ON), c 0x0060 0x0060 (সঙ্গে LED ON), d 0x0020 0x0020 (সঙ্গে ALARM OFF), e 0x0020 0x0020.

  4. হিসাব — LED আর open-drain: (ক) 3.3 V-এর একটি pin থেকে একটি লাল LED (Vf = 1.8 V ধরুন) প্রায় 3 mA-তে চালাতে E12 সারির কোন resistor নেবেন, আর আসল current কত? (খ) একটি open-drain লাইনে 10 kΩ pull-up আর 50 pF হলে ৭০% পর্যন্ত উঠতে কত সময়? (গ) সেই লাইন 0 থাকার সময় pull-up দিয়ে কত current?

    (ক) R = (3.3 − 1.8) ÷ 0.003 = 500 Ω; E12-এর পরের বড় মান 560 Ω; I = 1.5 V ÷ 560 Ω ≈ 2.68 mA. (খ) τ = 10 kΩ × 50 pF = 500 ns; t = −τ × ln(0.3) ≈ 1.204 × 500 ns ≈ 602 ns. (গ) I = 3.3 V ÷ 10 kΩ = 0.33 mA, যা যে pin 0 টানছে সে নিজের ভেতরে নেয়। তিনটি মান অংশ ৮-এর block-এর সূত্রে Python-এ চালিয়ে মেলানো: 560 Ohm, 2.68 mA, tau = 500 ns, t(70%) = 602 ns, 330.0 uA. লক্ষ করুন, 470 Ω নিলে current হতো প্রায় 3.19 mA, লক্ষ্যের চেয়ে বেশি; তাই সবসময় ওপরের দিকে গোল করুন।

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

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

ক্রমSTM32F103-এ reset-এর পরে PA5-কে push-pull output বানিয়ে LED জ্বালানোর ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. RCC-র APB2ENR-এ IOPAEN বিট 1 করে port A-র clock চালু করা
  2. BRR বা BSRR দিয়ে PA5-এর ODR-এর বিট আগে থেকে 0 করা, যাতে mode বদলের মুহূর্তে LED না জ্বলে
  3. CRL পড়ে PA5-এর ৪ বিট (বিট ২৩–২০) মুছে ফেলা
  4. সেই জায়গায় 0x2 (CNF 00, MODE 10) বসিয়ে CRL-এ লেখা
  5. BSRR-এ 1u << 5 লিখে LED জ্বালানো

একটি বোতামের এক পা microcontroller-এর input pin-এ আর অন্য পা GND-তে; pin-এ internal pull-up চালু। বোতাম চাপলে pin কী পড়বে, আর এই ধরনের নাম কী?

  • 1, active-high
  • 0, active-low
  • অনিশ্চিত, floating
  • 0, active-high

তিনটি device-এর output একটি সাধারণ তারে জোড়া, তারে একটি pull-up resistor. যেকোনো একটি device তারকে 0 করতে পারবে, আর কখনো short হবে না, এমন নকশায় output-গুলো কোন mode-এ রাখবেন?

  • Push-pull, 50 MHz
  • Analog
  • Open-drain
  • Floating input

STM32F103-এ (RM0008) GPIOA_CRL-এর মান 0x44444444. PA5-কে general-purpose push-pull output, সর্বোচ্চ 2 MHz বানালে CRL-এর নতুন মান কত হবে?

  • 0x44244444
  • 0x44344444
  • 0x44424444
  • 0x44644444

STM32F103-এর একটি input pin-কে CNF = 10 (input with pull-up/pull-down) বানানো হলো। Pull-up না pull-down, তা কী ঠিক করে?

  • CRL-এর MODE বিট
  • IDR-এর সেই pin-এর বিট
  • PUPDR register
  • ODR-এর সেই pin-এর বিট

3.3 V-এর একটি GPIO pin থেকে একটি LED চালাতে হবে, LED-এর Vf = 2.0 V আর লক্ষ্য current 5 mA. E12 সারি থেকে সবচেয়ে উপযুক্ত resistor কোনটি?

  • 220 Ω
  • 270 Ω
  • 680 Ω
  • কোনো resistor লাগবে না

একটি STM32-ধাঁচের GPIO-তে ODR = 0x0060. BSRR-এ 0x00400040 লেখা হলো (একই বিট ৬-এ set আর reset দুটোই 1). ST-এর reference manual RM0008-এর নিয়মে নতুন ODR কত?

  • 0x0020
  • 0x0040
  • 0x0060
  • 0x0000

শব্দকোষ

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

মনে রাখুন

  1. Input: কখনো ভাসমান নয়; pull-up দিলে বোতাম GND-তে আর active-low (চাপা = 0), pull-down দিলে VDD-তে আর active-high; ADC আর অব্যবহৃত pin analog.
  2. Output: push-pull 0 আর 1 দুটোই চালায়; open-drain শুধু 0, 1 আসে pull-up থেকে, এক তারে অনেকজন মিলে wired-AND; গতি যতটুকু দরকার, ততটুকুই।
  3. STM32F103: প্রতি pin ৪ বিট (CNF:MODE) CRL/CRH-এ, reset 0x44444444; pull-এর দিক ODR-এর বিটে; আগে RCC-তে clock, আগে ODR, তারপর mode.
  4. Board-এর আসল run: IDR output-ও দেখায়; BSRR/BRR এক store; একই বিটে set আর reset হলে set জেতে (board আর ST দুটোতেই); byte-এর লেখা বাকি byte মোছে; BSRR পড়লে HardFault.
  5. বিদ্যুৎ: LED-এ R = (VDD − Vf) ÷ I, ওপরের দিকে গোল; প্রতি pin আর পুরো chip-এর current-এর সীমা datasheet-এ; বাইরের তারে series resistor, 5 V শুধু FT pin-এ, mains কখনো নয়।

পরের পর্বে: পর্ব ৪২ (Button debouncing). যান্ত্রিক বোতামের লাফানো সংকেত, counter আর shift-register দিয়ে software debouncing, RC আর Schmitt trigger দিয়ে hardware debouncing, আর board-এ লাফানো বোতামের আসল run.

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

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