এই পর্বে যা শিখবেন
- RS-485-এর differential জোড়া, half-duplex, termination, failsafe bias আর unit load দিয়ে একটি গুদামের bus নকশা করা
- Modbus RTU-র frame, function code 03 আর 06, exception response আর register-এর নম্বর পড়া ও বানানো
- CRC-16/MODBUS বিট ধরে হিসাব করা, প্রকাশিত test vector দিয়ে নিজের কোড যাচাই করা
- 1-Wire-এর reset, presence আর time slot-এর সময়, আর ROM-এর CRC-8
- USB enumeration-এর ধাপ, endpoint, descriptor আর CDC/HID class, আর কোন কাজে কোন interface
১ · বাজারঘরের গুদামে নতুন সমস্যা — তার লম্বা, যন্ত্র অনেক
বাজারঘরের cold-storage monitor এতদিন দোকানের ভেতরে ছিল। এখন সে বসবে পেছনের গুদামের ঠান্ডা ঘরে, আর অফিসের একটি controller প্রতি সেকেন্ডে তার তাপমাত্রা আর alarm জানতে চায়। তার যাবে প্রায় ৫০ মিটার, পথে আছে compressor-এর মোটর। পরে একই তারে smart scale-ও যুক্ত হবে। পর্ব ৪৯-এর TTL UART এখানে টিকবে না: সেটি এক-এক সংযোগ, ছোট তারের জন্য, আর মোটরের noise সরাসরি ঢোকে।
এই পর্বে চারটি interface, যেগুলো এমন বাস্তব সমস্যার উত্তর:
- RS-485: লম্বা তার আর অনেক যন্ত্রের জন্য বৈদ্যুতিক স্তর।
- Modbus RTU: সেই তারে কে কখন কথা বলবে আর byte-এর মানে কী, তার নিয়ম।
- 1-Wire: এক তারে ছোট sensor, যেমন ঠান্ডা ঘরের একটি বাড়তি তাপমাত্রার probe.
- USB: কম্পিউটারের সঙ্গে প্লাগ লাগিয়েই কথা বলা।
উপমা — স্কুলের রোল কল: ক্লাসে শিক্ষক (master) নাম ধরে ডাকেন, “রোল ৭?”, আর শুধু রোল ৭ “উপস্থিত” বলে। কেউ নিজে থেকে কথা বলে না, তাই দুজন একসাথে বলে না। শিক্ষক পুরো ক্লাসের উদ্দেশে কোনো নির্দেশ দিলে কেউ উত্তর দেয় না, শুধু কাজটি করে। আর শিক্ষকের কথা অস্পষ্ট হলে ছাত্র চুপ থাকে; শিক্ষক আবার ডাকেন। Modbus ঠিক এই রোল কল: রোল নম্বর হলো slave address, পুরো ক্লাসের নির্দেশ হলো broadcast, আর অস্পষ্ট কথা হলো CRC-এর ভুল।
এই পর্বে hex লেখা হবে C-ধাঁচে (0x0190), আর তারে যাওয়া byte-গুলো ফাঁক রেখে (01 03 …). কোর্সের virtual board-এ USB, RS-485 transceiver বা 1-Wire নেই, আছে একটি UART (Spec decision 24). তাই Modbus RTU-র frame, CRC আর slave-এর যুক্তি board-এ সত্যিই চলবে, আর USB, 1-Wire ও RS-485-এর বৈদ্যুতিক দিক আসবে মান আর app note থেকে, ব্রাউজারের Python মডেল দিয়ে যাচাই করে।
২ · RS-485 — differential জোড়া, অনেক যন্ত্র, দুই প্রান্তে termination
RS-485 নিজে কোনো protocol নয়, শুধু বৈদ্যুতিক মান: driver আর receiver কেমন ভোল্টেজ দেবে আর বুঝবে। TI-এর “The RS-485 Design Guide” (SLLA272D) অনুযায়ী EIA ১৯৮৩ সালে মানটি অনুমোদন করে। মূল কৌশল differential signaling: একটি বিট যায় দুটি তারে, A আর B, উল্টো দিকে। গ্রাহক দুই তারের পার্থক্য দেখে। মোটরের noise দুই পাশাকাছি তারে প্রায় সমান ঢোকে, তাই পার্থক্যে বাদ পড়ে যায়; পর্ব ৫২-এর CAN-ও একই কৌশলে চলে। তত্ত্বটি Computer Networks পর্ব ০৮-এ আছে; এখানে নকশার সংখ্যা।
| বিষয় | মান (TI SLLA272D) | মানে |
|---|---|---|
| Driver-এর output | 54 Ω load-এ অন্তত 1.5 V পার্থক্য | দুই প্রান্তের termination আর অনেক যন্ত্রের ভারেও যথেষ্ট সংকেত |
| Receiver-এর সীমা | 200 mV পার্থক্য | সংকেত ক্ষয়ে ৭ ভাগের এক ভাগ হলেও পড়া যায় |
| Common-mode পরিসর | −7 V থেকে +12 V | দুই যন্ত্রের ground একটু আলাদা হলেও চলে |
| Bus-এর ভার | ৩২ unit load (১ UL ≈ 12 kΩ) | ⅛ UL-এর transceiver হলে ২৫৬টি পর্যন্ত |
| দূরত্ব আর গতি | 100 kbps-এ প্রায় 1200 m (4000 ft); 10 Mbps মাত্র কয়েক মিটারে | গতি × দূরত্ব একসাথে বাড়ানো যায় না |
Modbus-এর সাধারণ রূপ half-duplex দুই তারের bus: সব যন্ত্র একই জোড়ায়, একসময়ে মাত্র একজন driver চালু। এটিই multi-drop. তাই প্রতিটি transceiver-এর একটি DE (driver enable) pin থাকে, যা firmware পাঠানোর ঠিক আগে চালু আর শেষ stop বিট বেরোনোর পরে বন্ধ করে। Modbus over Serial Line V1.02 (Modbus Organization, ২০০৬) এর নাম দেয় D1 = B, D0 = A, আর B > A মানে বিট 1. তৃতীয় একটি “common” তারও বাধ্যতামূলক।
ছবি ৫৩.১ — বাজারঘরের গুদামের RS-485 bus
একটি master, দুটি slave; দুই প্রান্তে termination, master-এর কাছে bias
Termination কেন? লম্বা তার একটি transmission line: সংকেত শেষ প্রান্তে গিয়ে ধাক্কা খেয়ে ফিরে আসে, যদি না সেখানে তারের নিজের impedance-এর সমান resistor থাকে। RS-485-এর twisted pair-এর impedance সাধারণত 120 Ω, তাই দুই প্রান্তে 120 Ω. Modbus spec বলে 150 Ω (0.5 W), অথবা bias থাকলে 1 nF-এর সঙ্গে সিরিজে 120 Ω; আর এক জোড়ায় দুটির বেশি termination নয়, শাখা-তারে কখনো নয়।
Bias কেন? Modbus-এ কেউ না বললে কোনো driver চালু থাকে না, লাইন ভাসে, আর receiver noise থেকে এলোমেলো বিট পড়তে পারে, যা দেখতে start বিটের মতো। তাই bus-এর একটি জায়গায় (সাধারণত master-এ) B-কে 5 V-এ pull-up আর A-কে common-এ pull-down করা হয়। Spec দুটির মান 450 থেকে 650 Ω দেয়। 650 Ω আর দুই প্রান্তে 150 Ω হলে নীরব লাইনে A–B পার্থক্য 5 × 75 ÷ (650 + 75 + 650) ≈ 0.27 V, receiver-এর 200 mV সীমার ওপরে, তাই লাইন নিশ্চিতভাবে “1” (idle). (হিসাব আমার lab-এর stepcrc.py-তে; 120 Ω-এ নামে 0.22 V.)
নিরাপত্তা আর ground: গুদাম আর অফিস প্রায়ই বিদ্যুতের আলাদা লাইন থেকে চলে, তাই দুই যন্ত্রের ground-এর মধ্যে কয়েক ভোল্টের পার্থক্য থাকতে পারে। −7 থেকে +12 V-এর সীমা পেরোলে transceiver নষ্ট হতে পারে, আর ground-এর তারে বড় স্রোতও বইতে পারে (TI-এর guide একে “ground loop” বলে). Spec common তারকে মাত্র এক জায়গায় protective earth-এ যুক্ত করতে বলে। দূরের বা মোটর-ঘেরা যন্ত্রে isolated transceiver ব্যবহার করুন। Mains-এর panel বা compressor-এর তার নিজে খুলবেন না; সেটি যোগ্য electrician-এর কাজ।
৩ · Modbus RTU — frame, function code আর exception
Modbus একটি master-slave protocol: Modbus over Serial Line V1.02-এর ভাষায় “slave কখনো অনুরোধ ছাড়া কিছু পাঠায় না, আর slave-রা নিজেদের মধ্যে কথা বলে না”. ঠিকানার নিয়ম: 0 = broadcast, 1 থেকে 247 = slave, 248 থেকে 255 সংরক্ষিত। serial লাইনে দুটি রূপ আছে, ASCII আর RTU; সব যন্ত্রে RTU থাকতেই হবে, তাই আমরা RTU-ই দেখব।
- প্রতি byte ১১ বিট: start, ৮ data (LSB আগে), parity, stop. ডিফল্ট even parity; parity না থাকলে দুটি stop বিট, যাতে মোট ১১ থাকে। পর্ব ৪৯-এর ভাষায় 8E1 বা 8N2.
- Frame: address (১ byte) + function code (১) + data (০ থেকে ২৫২) + CRC (২, নিচের byte আগে). সর্বোচ্চ ২৫৬ byte.
- Frame-এর সীমানা নীরবতা দিয়ে: frame-এর আগে-পরে অন্তত ৩.৫ অক্ষরের নীরবতা (t3.5); frame-এর ভেতরে দুটি অক্ষরের মাঝে ১.৫ অক্ষরের বেশি ফাঁক হলে frame অসম্পূর্ণ, ফেলে দিতে হয়। 19200 baud-এর বেশি গতিতে spec স্থির মান দিতে বলে: 750 µs আর 1.750 ms.
Modbus-এর data-র একক হলো holding register, ১৬ বিটের একটি ঘর। Application Protocol Specification V1.1b3 অনুযায়ী register-এর মান big-endian-এ যায়: বড় byte আগে। এই পর্বে দুটি function code:
| Code | কাজ | অনুরোধ (address-এর পরে) | স্বাভাবিক উত্তর |
|---|---|---|---|
| 03 | Read Holding Registers | 03, শুরুর ঠিকানা (২), সংখ্যা N (২, ১ থেকে ১২৫) | 03, byte count = 2N, তারপর N টি মান |
| 06 | Write Single Register | 06, ঠিকানা (২), মান (২) | অনুরোধের হুবহু প্রতিধ্বনি (echo) |
অনুরোধ বোঝা গেলেও করা না গেলে slave পাঠায় exception response: function code-এর সঙ্গে 0x80 যোগ করে, তারপর একটি কারণ-কোড। সবচেয়ে প্রচলিত কোড: 01 ILLEGAL FUNCTION (এই code চেনে না), 02 ILLEGAL DATA ADDRESS (এই ঠিকানায় register নেই), 03 ILLEGAL DATA VALUE (অনুরোধের গঠনে ভুল, যেমন N = 0), 04 SERVER DEVICE FAILURE. আর CRC ভুল হলে? কোনো উত্তরই নয়: slave ধরে নেয় frame-টি তার কাছে পৌঁছায়নি, master-এর response timeout শেষে আবার চেষ্টা।
Cold-room monitor-কে slave 1 করে এই পর্বের নকশায় ছয়টি holding register দেওয়া হলো, README-র সংখ্যা মেনে (তাপমাত্রা ×১০০, যাতে ১৬ বিটের পূর্ণসংখ্যায় দশমিক থাকে):
| PDU ঠিকানা | প্রচলিত নম্বর | মান | লেখা যায়? |
|---|---|---|---|
| 0 | 40001 | তাপমাত্রা × 100, signed (400 = 4.00 °C) | না |
| 1 | 40002 | alarm: 0 = OFF, 1 = HIGH, 2 = LOW | না |
| 2 | 40003 | high limit × 100 (800 = 8.00 °C) | হ্যাঁ |
| 3 | 40004 | low limit × 100 (0) | হ্যাঁ |
| 4 | 40005 | hysteresis × 100 (50 = 0.50 °C) | না |
| 5 | 40006 | reset-এর পরে কয়টি reading | না |
“প্রচলিত নম্বর” কলামটি একটি পরিচিত ফাঁদ। পুরোনো Modicon-ধাঁচের তালিকায় holding register গোনা হয় 40001 থেকে, কিন্তু তারে যায় 0 থেকে গোনা ঠিকানা: spec নিজেই বলে “register 1–16 ঠিকানা পায় 0–15”. কোনো যন্ত্রের manual-এ “40003” দেখলে frame-এ লিখতে হবে 0x0002.
req01 03req00 00 00 02crcC4 0Bchkযাচাইresp01 03 04 01 90 00 00crcFB E2
| কে | |
| byte | |
| মানে |
- PDU বানানো। master লেখে ঠিকানা 01, function 03, শুরুর register 00 00, সংখ্যা 00 02. দুই byte-এর সংখ্যা big-endian: বড় byte আগে।
- CRC জোড়া। ছয় byte-এর CRC-16 = 0x0BC4. তারে যায় নিচের byte আগে, তাই frame-এর শেষে
C4 0B. CRC-এর byte-ক্রম register-এর উল্টো, এটি পরীক্ষার প্রিয় প্রশ্ন। - তারে। ৮টি অক্ষর × ১১ বিট = ৮৮ বিট; 9600 baud-এ 9.17 ms. শেষ byte-এর পরে লাইন অন্তত t3.5 = 4.01 ms চুপ, তাতেই slave বোঝে frame শেষ।
- Slave-এর যাচাই। ঠিকানা 1, নিজের। CRC সহ পুরো ৮ byte-এর CRC = 0000 (CRC ঠিক থাকলে সবসময় শূন্য). FC 03 চেনা, N = 2 বৈধ, register 0 আর 1 আছে।
- উত্তর বানানো। 01 03, byte count 04, তারপর reg 0 = 0x0190 আর reg 1 = 0x0000, শেষে CRC 0xE2FB, তাই
FB E2. Board-এর run-এ উত্তর বেরিয়েছে 1500.2088 ms-এ। - Master পড়ে। ৯ byte-এর CRC 0000, ঠিক। 0x0190 = 400, অর্থাৎ 4.00 °C; alarm 0, OFF. README-র cold room ঠিক এই তাপমাত্রায় শুরু হয়।
৪ · CRC-16 বিট ধরে — spec-এর পদ্ধতি আর test vector
পর্ব ৪৯-এর XOR checksum ক্রম-বদল ধরতে পারেনি। Modbus RTU ব্যবহার করে CRC-16. গণিতের দিক (polynomial ভাগ আর ভাগশেষ) Computer Networks পর্ব ০৯-এ। এখানে spec-এর নিজের রেসিপি, Modbus over Serial Line V1.02-এর §6.2.2 থেকে:
- ১৬ বিটের CRC register-এ 0xFFFF রাখুন।
- বার্তার প্রথম byte register-এর নিচের byte-এর সঙ্গে XOR করুন।
- register এক বিট ডানে সরান (ওপরে 0 ঢোকে); বেরিয়ে যাওয়া বিট (LSB) দেখুন।
- সেই বিট 1 হলে register-কে 0xA001 দিয়ে XOR করুন; 0 হলে কিছু নয়।
- ধাপ ৩–৪ মোট আটবার; তারপর পরের byte নিয়ে ধাপ ২ থেকে, শেষ byte পর্যন্ত।
0xA001 হলো x16 + x15 + x2 + 1 polynomial (0x8005)-এর বিট-উল্টো রূপ, কারণ এখানে LSB আগে আসে। Spec-এর পরিশিষ্টে ছোট একটি উদাহরণ আছে: দুই byte 02 07-এর CRC 0x1241. নিচের stepper সেটি ধাপে ধাপে মেলায়:
initcrc = 0xFFFF; crc ^= 0x02shftlsb = crc & 1; crc >>= 1xorcrc ^= 0xA001b2crc ^= 0x078xসরানো + XORtxনিচের byte আগে
| hex | |
| binary | |
| কী হলো |
- শুরু আর প্রথম XOR. register সব 1 = 0xFFFF; প্রথম byte 0x02-এর সঙ্গে XOR করে 0xFFFD.
- প্রথম দুটি সরানো। 0xFFFD-এর LSB 1: সরিয়ে 0x7FFE, XOR 0xA001 = 0xDFFF. আবার LSB 1: 0x6FFF, XOR করে 0xCFFE.
- বাকি ছয়টি। বেরোনো বিট পরপর 0, 1, 0, 1, 0, 1; যেবার 1, সেবার 0xA001-এর XOR. আটবারের শেষে 0x813E, spec-এর টেবিলে যা 1000 0001 0011 1110.
- দ্বিতীয় byte. 0x813E XOR 0x07 = 0x8139.
- আবার আটবার। বেরোনো বিট 1, 1, 1, 0, 1, 0, 0, 0. শেষে 0x1241, spec-এর উত্তরের সঙ্গে হুবহু এক।
- Frame-এ বসানো। নিচের byte 0x41 আগে, তারপর 0x12: তারে
02 07 41 12. গ্রাহক এই চার byte-এর CRC নিলে পাবে 0x0000.
এবার একই রেসিপি Python-এ, দুটি প্রকাশিত test vector সহ: spec-এর 02 07 → 0x1241, আর CRC-এর বহুল ব্যবহৃত “reveng” তালিকায় CRC-16/MODBUS-এর check মান, “123456789” → 0x4B37. যেকোনো CRC কোড (নিজের বা AI-এর) এই দুটি মেলাতে না পারলে বিশ্বাস করবেন না।
# Modbus RTU: CRC-16 (Modbus over Serial Line V1.02 §6.2.2) আর FC 03-এর frame
def crc16(data):
crc = 0xFFFF # ধাপ ১: সব বিট 1
for b in data:
crc ^= b # ধাপ ২: নিচের byte-এ XOR
for _ in range(8): # ধাপ ৩-৫: ৮ বার ডানে সরানো
crc = (crc >> 1) ^ 0xA001 if crc & 1 else crc >> 1
return crc
def rtu(pdu): # CRC জোড়া: নিচের byte আগে
c = crc16(pdu)
return pdu + bytes([c & 0xFF, c >> 8])
hx = lambda b: " ".join(f"{x:02X}" for x in b)
print("test '123456789':", f"{crc16(b'123456789'):04X}", "(প্রকাশিত check 4B37)")
print("test 02 07 :", f"{crc16(bytes([2, 7])):04X}", "(spec-এর উদাহরণ 1241)")
req = rtu(bytes([0x01, 0x03, 0x00, 0x00, 0x00, 0x02])) # slave 1, reg 0 থেকে 2টি
print("request :", hx(req), "| পুরোটার CRC =", f"{crc16(req):04X}")
resp = bytes.fromhex("01 03 04 01 90 00 00 FB E2") # board-এর আসল উত্তর
ok = crc16(resp) == 0
temp = int.from_bytes(resp[3:5], "big", signed=True)
print("response:", hx(resp), "| CRC ঠিক:", ok,
f"| reg0 = {temp} -> {temp / 100:.2f} C, reg1 (alarm) = {resp[6]}")
bad = bytearray(req); bad[5] = 0x20 # পথে একটি byte বদলাল
print("নষ্ট :", hx(bad), "| CRC =", f"{crc16(bad):04X}", "-> slave চুপ")
for baud in (9600, 19200, 115200): # 8E1 = ১১ বিট প্রতি অক্ষর
ch = 11 / baud * 1000 # ms
t35 = 3.5 * ch if baud <= 19200 else 1.75
t15 = 1.5 * ch if baud <= 19200 else 0.75
cyc = (8 + 9) * ch + 2 * t35 # প্রশ্ন + উত্তর + দুটি নীরবতা
print(f"{baud:6} baud: অক্ষর {ch:.3f} ms, t1.5 {t15:.3f}, t3.5 {t35:.3f},"
f" এক poll ≥ {cyc:.2f} ms")আসল আউটপুট (ব্রাউজারের Python):
test '123456789': 4B37 (প্রকাশিত check 4B37)
test 02 07 : 1241 (spec-এর উদাহরণ 1241)
request : 01 03 00 00 00 02 C4 0B | পুরোটার CRC = 0000
response: 01 03 04 01 90 00 00 FB E2 | CRC ঠিক: True | reg0 = 400 -> 4.00 C, reg1 (alarm) = 0
নষ্ট : 01 03 00 00 00 20 C4 0B | CRC = 0AA0 -> slave চুপ
9600 baud: অক্ষর 1.146 ms, t1.5 1.719, t3.5 4.010, এক poll ≥ 27.50 ms
19200 baud: অক্ষর 0.573 ms, t1.5 0.859, t3.5 2.005, এক poll ≥ 13.75 ms
115200 baud: অক্ষর 0.095 ms, t1.5 0.750, t3.5 1.750, এক poll ≥ 5.12 ms
দুটি test vector মিলেছে, আর আমার lab-এ table-ভিত্তিক ও সাধারণ polynomial-ভাগের আরও দুটি আলাদা implementation ২০,০০০ এলোমেলো বার্তায় একই ফল দিয়েছে (mbhost.py). board-এর আসল উত্তরের CRC ঠিক, তাপমাত্রা 4.00 °C. একটি byte বদলালে (0x02 → 0x20) পুরো frame-এর CRC আর 0 থাকে না, slave চুপ। শেষ তিন লাইন নকশার সংখ্যা: 9600 baud-এ দুটি register পড়ার একটি প্রশ্ন-উত্তর অন্তত 27.5 ms (slave-এর ভাবার সময় বাদে), তাই এক সেকেন্ডে এক master বড়জোর ছত্রিশটির মতো এমন poll করতে পারে। 19200-এর ওপরে t3.5 স্থির 1.75 ms, spec-এর সুপারিশ মেনে।
Firmware C-তে একই অঙ্ক, আর সঙ্গে প্রমাণ যে CRC ক্রম-বদল ধরে। নিচের কোড Wandbox-এ চলে:
#include <stdio.h>
#include <stdint.h>
static uint16_t crc16(const uint8_t *p, int n) /* CRC-16/MODBUS */
{
uint16_t c = 0xFFFF;
while (n--) { c ^= *p++; for (int i = 0; i < 8; i++) c = (c & 1) ? (c >> 1) ^ 0xA001 : c >> 1; }
return c;
}
int main(void)
{
const uint8_t chk[] = "123456789", a[] = {1, 6, 0, 2, 0x03, 0xE8}, b[] = {1, 6, 0, 2, 0xE8, 0x03};
printf("CRC(\"123456789\") = %04X\n", crc16(chk, 9));
uint8_t xa = 0, xb = 0; /* XOR checksum, for comparison */
for (int i = 0; i < 6; i++) { xa ^= a[i]; xb ^= b[i]; }
printf("03 E8: XOR %02X CRC %04X\nE8 03: XOR %02X CRC %04X\n", xa, crc16(a, 6), xb, crc16(b, 6));
int miss = 0; /* flip each of the 48 bits of a */
for (int k = 0; k < 48; k++) { uint8_t m[6]; for (int i = 0; i < 6; i++) m[i] = a[i];
m[k / 8] ^= (uint8_t)(1u << (k % 8)); miss += crc16(m, 6) == crc16(a, 6); }
printf("48 single-bit errors, CRC missed: %d\n", miss);
return 0;
}আসল আউটপুট (আমার lab-এ Clang 22.1.8, আর Wandbox-এ একই):
CRC("123456789") = 4B37
03 E8: XOR EE CRC B428
E8 03: XOR EE CRC 0B26
48 single-bit errors, CRC missed: 0
“high limit = 1000” (03 E8) আর ভুল ক্রমের E8 03, যা 59395 বা ঋণাত্মক −6141: XOR checksum দুটিতেই 0xEE, পার্থক্য দেখে না। CRC দুটি আলাদা মান দেয়, আর ৪৮টি এক-বিটের ভুলের সবকটি ধরে। Modbus-এর CRC তাই প্রতিটি অক্ষরের parity-র ওপরে দ্বিতীয় স্তর: parity একটি অক্ষর দেখে, CRC পুরো frame.
৫ · সত্যিকারের run — board-এ cold room একটি Modbus slave
এবার কোর্সের virtual বাজারঘর board-এ (BG-M3, আসল কোনো পণ্য নয়; firmware Clang 22.1.8-এ Thumb কোডে compile হয়, Unicorn-এ চলে, পর্ব ০৬). আমার lab-এর modbus_slave.c reference-এর coldroom.c আর uart_hello.c জুড়ে বানানো: প্রতি সেকেন্ডে I2C-ধাঁচের sensor থেকে তাপমাত্রা পড়ে README-র alarm-নিয়মে (তিন reading, 0.50 °C hysteresis) register ভরে, আর UART-এর RXNE interrupt আর ring buffer (পর্ব ৪৯) দিয়ে frame নেয়।
সৎ সীমা: board-এর script শুধু লেখা (text) পাঠাতে পারে, যেকোনো byte নয়। তাই master-এর প্রতিটি RTU frame আসে hex লেখার এক লাইনে, আর লাইনের শেষ (\n) দাঁড়ায় t3.5-এর নীরবতার জায়গায়। firmware লাইনটিকে আসল byte-এ রূপ দিয়ে তারপর binary frame হিসেবেই সামলায়, আর উত্তর ছাপে TX … লাইনে। # দিয়ে শুরু লাইনগুলো debug: আসল slave এগুলো RS-485 bus-এ কখনো পাঠাবে না। board-এর UART baud মাপে না (Spec decision 24), তাই t1.5 আর t3.5-এর timer এখানে পরীক্ষা হয়নি।
Frame সামলানোর মূল অংশ (debug-লাইন বাদ দিয়ে):
static void handle(const uint8_t *f, uint32_t n) /* একটি পুরো RTU frame */
{
if (n < 4u)
return;
if (crc16(f, n) != 0u) { crc_errors++; return; } /* CRC ভুল: চুপ থাকা */
uint8_t addr = f[0], fc = f[1];
if (addr != MY_ADDR && addr != 0u) return; /* অন্যের frame */
if (fc != 3u && fc != 6u) { if (addr) exception(fc, 1); return; }
if (n != 8u) { if (addr) exception(fc, 3); return; }
uint16_t a = (uint16_t)(f[2] << 8 | f[3]); /* big-endian */
uint16_t v = (uint16_t)(f[4] << 8 | f[5]);
if (fc == 3u) {
if (addr == 0u) return; /* read কখনো broadcast নয় */
if (v < 1u || v > 125u) { exception(fc, 3); return; }
if ((uint32_t)a + v > NREGS) { exception(fc, 2); return; }
uint8_t r[3 + 2 * NREGS + 2] = { MY_ADDR, 3, (uint8_t)(2u * v) };
for (uint32_t i = 0; i < v; i++) {
r[3 + 2 * i] = (uint8_t)((uint16_t)regs[a + i] >> 8);
r[4 + 2 * i] = (uint8_t)((uint16_t)regs[a + i] & 0xFFu);
}
send(r, 3u + 2u * v); /* CRC জুড়ে পাঠায় */
} else { /* fc == 6 */
if (a != 2u && a != 3u) { if (addr) exception(fc, 2); return; }
regs[a] = (int16_t)v; /* broadcast-ও লেখে */
if (addr) { uint8_t r[8]; for (int i = 0; i < 6; i++) r[i] = f[i]; send(r, 6); }
}
}Script-এ master প্রথমে স্বাভাবিক প্রশ্ন করে, তারপর ইচ্ছা করে ভুল: নষ্ট CRC, অন্য slave-এর frame, অচেনা function, না-থাকা register, লেখা-নিষেধ register আর একটি broadcast. মাঝে 2.5 s-এ ঘরের তাপমাত্রা 9.50 °C:
সত্যিকারের run — board.py run build/modbus_slave.elf --script modbus.json (Clang 22.1.8)
[ 0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[ 0.0000 ms] > cold-room temperature: +4.00 C
[ 0.0694 ms] UART: # modbus slave 1 (cold room), FC 03/06, 6 holding registers
[ 1500.0000 ms] > UART RX '01 03 00 00 00 02 C4 0B\n'
[ 1500.2088 ms] UART: TX 01 03 04 01 90 00 00 FB E2
[ 2500.0000 ms] > cold-room temperature: +9.50 C
[ 5000.0526 ms] UART: # alarm HIGH (reg1=1)
[ 5000.0538 ms] GPIO PA6 ALARM ON
[ 5500.0000 ms] > UART RX '01 03 00 00 00 06 C5 C8\n'
[ 5500.2505 ms] UART: TX 01 03 0C 03 B6 00 01 03 20 00 00 00 32 00 05 D2 B5
[ 5700.0000 ms] > UART RX '01 06 00 02 03 E8 28 B4\n'
[ 5700.1829 ms] UART: # reg 2 = 1000
[ 5700.2300 ms] UART: TX 01 06 00 02 03 E8 28 B4
[ 6500.0000 ms] > UART RX '01 03 00 00 00 02 C4 0A\n'
[ 6500.1954 ms] UART: # CRC error, frame dropped, no reply (crc_errors=1)
[ 7000.0000 ms] > UART RX '02 03 00 00 00 02 C4 38\n'
[ 7000.1878 ms] UART: # frame for slave 2, ignored
[ 7500.0000 ms] > UART RX '01 04 00 00 00 01 31 CA\n'
[ 7500.1812 ms] UART: TX 01 84 01 82 C0
[ 8000.0525 ms] UART: # alarm OFF (reg1=0)
[ 8000.0536 ms] GPIO PA6 ALARM OFF
[ 8200.0000 ms] > UART RX '01 03 00 06 00 01 64 0B\n'
[ 8200.1849 ms] UART: TX 01 83 02 C0 F1
[ 8400.0000 ms] > UART RX '01 06 00 00 00 7B C9 E9\n'
[ 8400.1849 ms] UART: TX 01 86 02 C3 A1
[ 8600.0000 ms] > UART RX '00 06 00 03 00 32 F9 CE\n'
[ 8600.1951 ms] UART: # reg 3 = 50 (broadcast, no reply)
[ 9500.0000 ms] > UART RX '01 03 00 00 00 06 C5 C8\n'
[ 9500.2505 ms] UART: TX 01 03 0C 03 B6 00 00 03 E8 00 32 00 32 00 09 AF 28
[ 10010.0717 ms] UART: # replies=7 crc_errors=1 other_addr=1
[ 10010.0726 ms] exit(0) after 80080581 cycles
প্রতিটি TX লাইন আমার lab-এর verify_run.py host-এর Python CRC দিয়ে আলাদা করে মিলিয়েছে: সাতটির সবকটির CRC ঠিক, লেখার উত্তর অনুরোধের হুবহু echo. লক্ষ্য করুন:
- 5 s-এ alarm HIGH: 3, 4, 5 s-এর তিনটি reading 9.50 °C, তাই README-র নিয়মে alarm. 5.5 s-এর উত্তরে ছয়টি register: 0x03B6 = 950, alarm 1, limit 800, 0, 50, আর ৫টি reading.
- Limit বদলালে alarm ফিরল: 5.7 s-এ master high limit 1000 (10.00 °C) লিখল। নতুন “ঠিক আছে” পরিসর 0.50 থেকে 9.50 °C, আর 9.50 তার ভেতরে; 6, 7, 8 s-এর তিন reading-এর পরে 8 s-এ alarm OFF.
- তিন রকম নীরবতা: নষ্ট CRC (6.5 s), slave 2-এর frame (7 s) আর broadcast (8.6 s): কোনোটিতে
TXনেই। Broadcast-এর লেখা তবু কার্যকর: 9.5 s-এর উত্তরে reg 3 = 0x0032 = 50. - তিনটি exception:
84 01(FC 04 এই slave চেনে না),83 02(register 6 নেই),86 02(register 0 লেখা যায় না).
৬ · 1-Wire — এক তারে কথা, সময় দিয়ে বিট
1-Wire হলো Dallas Semiconductor-এর (পরে Maxim, এখন Analog Devices) নকশা করা bus, যেখানে data-র জন্য একটি মাত্র তার আর ground. তারটি open-drain (পর্ব ৪১): master বা slave শুধু টেনে 0 করতে পারে, 1 আসে একটি দুর্বল pull-up resistor থেকে। কোনো clock তার নেই; প্রতিটি বিট একটি নির্দিষ্ট time slot, আর 0 না 1, তা বোঝা যায় লাইন কতক্ষণ নিচে থাকল তা দিয়ে। কিছু chip “parasitic power” মোডে এই data তার থেকেই নিজের শক্তি জমিয়ে চলে। সবচেয়ে পরিচিত উদাহরণ DS18B20 তাপমাত্রার sensor, যা ঠান্ডা ঘরের একটি বাড়তি probe হতে পারত।
Maxim-এর Application Note 126 standard গতিতে এই সময়গুলো সুপারিশ করে: write 1 = 6 µs নিচে, তারপর 64 µs ছেড়ে দেওয়া; write 0 = 60 µs নিচে, তারপর 10 µs; read = 6 µs নিচে, 9 µs অপেক্ষা, লাইনের মান sample, তারপর 55 µs. আর reset = 480 µs নিচে, ছেড়ে 70 µs পরে sample, তারপর 410 µs. DS18B20-এর datasheet বলে, ছেড়ে দেওয়ার 15–60 µs পরে sensor 60–240 µs লাইন নিচে টানে: এটিই presence pulse.
ছবি ৫৩.২ — 1-Wire-এর reset আর presence
কালো মোটা = master টানছে; ধূসর মোটা = slave টানছে; লাল বিন্দু = master-এর sample
<0pull-up: 10master 480 µs টানে480ছাড়া, লাইন ওঠে510slave-এর presence550master-এর sample960write 1: 6 + 64 µs
| সময় (µs) | |
| লাইন | |
| ফল |
- Idle. কেউ টানছে না; pull-up লাইনকে 1-এ রাখে। Open-drain-এর কারণে দুজন একসাথে টানলেও কোনো সংঘর্ষ বা শর্ট নেই, শুধু লাইন 0.
- Reset pulse. master 480 µs লাইন নিচে ধরে রাখে, যেকোনো সাধারণ বিটের চেয়ে অনেক লম্বা, তাই বাসের সব slave বোঝে “নতুন করে শুরু”.
- ছেড়ে দেওয়া। 480 µs-এ master ছাড়ে, pull-up লাইন তোলে। slave এই ওঠা ধার দেখে 15–60 µs অপেক্ষা করে; ছবির ঘটনায় 30 µs.
- Presence. 510 µs থেকে slave 120 µs লাইন টানে, 630 µs পর্যন্ত। এটিই “উপস্থিত” বলা। একাধিক slave একসাথে টানলেও ফল একই: লাইন 0.
- Master-এর sample. ছাড়ার 70 µs পরে, 550 µs-এ, master লাইন পড়ে: 0, তাই অন্তত একটি device আছে। তারপর 410 µs অপেক্ষা; reset শেষ 960 µs-এ।
- প্রথম কমান্ড-বিট. Read ROM কমান্ড 0x33, LSB আগে, তাই প্রথম বিট 1: master 6 µs টেনে ছেড়ে দেয়, 64 µs অপেক্ষা। slot শেষ 1030 µs-এ। 0 হলে টানত 60 µs.
প্রতিটি 1-Wire chip-এ কারখানায় লেখা ৬৪ বিটের ROM code: নিচের byte family code (DS18B20-এর 0x28), মাঝের ৬ byte অনন্য serial নম্বর, ওপরের byte আগের সাত byte-এর CRC-8 (Maxim AN27, polynomial x8 + x5 + x4 + 1). ROM পড়া হয় LSB আগে। AN27-এর নিজের উদাহরণ: family 02, serial 00 00 00 01 B8 1C, CRC 0xA2. নিচের মডেল এই CRC, presence-এর সময়ের যুক্তি আর পড়ার খরচ মিলিয়ে দেখে:
# 1-Wire: reset/presence-এর সময়ের মডেল (AN126-এর মান) আর ROM-এর CRC-8
def crc8(data): # X^8 + X^5 + X^4 + 1, LSB আগে (Maxim AN27)
crc = 0
for b in data:
for _ in range(8):
mix = (crc ^ b) & 1
crc >>= 1
if mix:
crc ^= 0x8C # 0x31-এর উল্টো বিট-ক্রম
b >>= 1
return crc
an27 = bytes([0x02, 0x1C, 0xB8, 0x01, 0x00, 0x00, 0x00]) # family 02 আগে
print("AN27-এর ROM: CRC =", f"{crc8(an27):02X}", "(note-এ A2)")
print("'123456789' :", f"{crc8(b'123456789'):02X}", "(প্রকাশিত check A1)")
rom = bytes([0x28, 0x5A, 0x1B, 0x3C, 0x0D, 0x00, 0x00]) # বানানো DS18B20-ধাঁচ
full = rom + bytes([crc8(rom)])
print("বানানো ROM :", full[::-1].hex(" ").upper(), "| ৮ byte-এর CRC =", crc8(full))
# master: 480 µs নিচে টানে, ছেড়ে দেয়, 70 µs পরে sample (AN126)
def presence_seen(wait, low): # slave: wait µs পরে low µs নিচে
start, end = 480 + wait, 480 + wait + low
return start <= 480 + 70 < end, (start, end)
for wait, low in ((15, 60), (30, 120), (60, 60), (60, 240)):
seen, (s, e) = presence_seen(wait, low)
print(f"slave {wait:2} µs অপেক্ষা, {low:3} µs low -> লাইন 0: {s}-{e} µs,"
f" 550-এ sample: {'presence' if seen else 'নেই'}")
slot = {"write 1": 6 + 64, "write 0": 60 + 10, "read": 6 + 9 + 55}
print("time slot (µs):", slot)
t = 480 + 70 + 410 + 9 * 8 * 70 # reset + Read ROM (33h) + ৮ byte
print(f"reset + 0x33 + ৮ byte ROM পড়া = {t} µs = {t / 1000:.1f} ms")আসল আউটপুট (ব্রাউজারের Python):
AN27-এর ROM: CRC = A2 (note-এ A2)
'123456789' : A1 (প্রকাশিত check A1)
বানানো ROM : B9 00 00 0D 3C 1B 5A 28 | ৮ byte-এর CRC = 0
slave 15 µs অপেক্ষা, 60 µs low -> লাইন 0: 495-555 µs, 550-এ sample: presence
slave 30 µs অপেক্ষা, 120 µs low -> লাইন 0: 510-630 µs, 550-এ sample: presence
slave 60 µs অপেক্ষা, 60 µs low -> লাইন 0: 540-600 µs, 550-এ sample: presence
slave 60 µs অপেক্ষা, 240 µs low -> লাইন 0: 540-780 µs, 550-এ sample: presence
time slot (µs): {'write 1': 70, 'write 0': 70, 'read': 70}
reset + 0x33 + ৮ byte ROM পড়া = 6000 µs = 6.0 ms
দুটি প্রকাশিত মান মিলেছে: AN27-এর 0xA2 আর reveng-এর CRC-8/MAXIM-DOW-এর check 0xA1. বানানো ROM-এ CRC জুড়ে আট byte-এর CRC নিলে 0, যেমন Modbus-এ। চারটি চরম ঘটনাতেই 550 µs-এর sample presence-এর ভেতরে পড়ে, কারণ presence সবচেয়ে দেরিতে শুরু হয় ছাড়ার 60 µs পরে, আর সবচেয়ে আগে শেষ হয় 15 + 60 = 75 µs পরে; 70 এই দুইয়ের মাঝখানে। এটিই AN126-এর “70”-এর কারণ। আর গতি: প্রতি বিট 70 µs, মানে সেকেন্ডে প্রায় ১৪ হাজার বিট; একটি ROM পড়তে 6.0 ms. 1-Wire ধীর, কিন্তু একটি pin-এ অনেক sensor.
সময়ের শর্ত কঠিন: AN126 নিজেই বলে, এই কাজের মাঝে interrupt চলতে দেওয়া যাবে না। 6 µs-এর একটি টান যদি একটি ISR-এর কারণে 20 µs হয়, slave “1”-এর বদলে “0” পড়তে পারে। তাই firmware-এ সাধারণত প্রতিটি slot-এর ছোট অংশে interrupt বন্ধ রাখা হয় (পর্ব ৪৩-এর critical section), অথবা UART-কে বিশেষ কৌশলে 1-Wire-এর waveform বানাতে ব্যবহার করা হয়, যার বর্ণনা Maxim-এর আরেকটি app note-এ আছে।
৭ · USB — host প্রশ্ন করে, device পরিচয় দেয়
USB-এ সবকিছু host চালায়: device নিজে থেকে কখনো কথা বলে না, এমনকি keyboard-ও না; host নিয়মিত জিজ্ঞেস করে “নতুন কিছু?”. bus আর enumeration-এর architecture-স্তরের ছবি Computer Architecture পর্ব ৫১-এ; এখানে device-এর firmware-এর দিক থেকে দেখা। USB 2.0-এর তিনটি গতি: low 1.5 Mb/s, full 12 Mb/s, high 480 Mb/s. বেশিরভাগ microcontroller-এর ভেতরের USB full-speed. Device নিজের গতি জানায় একটি প্রায় 1.5 kΩ pull-up দিয়ে: full-speed D+-এ, low-speed D−-এ।
Device-এর ভেতরে কয়েকটি endpoint, অর্থাৎ data-র আলাদা দরজা, প্রতিটির একটি নম্বর আর দিক। Endpoint 0 সবসময় থাকে, control-এর জন্য: enumeration এখানেই। বাকিগুলো কাজের: bulk (বড় data, যেমন COM port-এর byte), interrupt (ছোট, নিয়মিত, যেমন keyboard), isochronous (সময়-বাঁধা, যেমন অডিও). Device নিজের পরিচয় দেয় descriptor দিয়ে: ১৮ byte-এর device descriptor (vendor ID, product ID, class, endpoint 0-এর packet-মাপ), তারপর configuration, interface আর endpoint descriptor. প্রতিটি control অনুরোধ শুরু হয় ৮ byte-এর SETUP packet দিয়ে।
devD+ pull-uphostreset (SE0)a0GET_DESCRIPTORa0SET_ADDRESS 7a7descriptor পুরোa7SET_CONFIG 1OSdriver
| SETUP (৮ byte) | |
| device-এর address | |
| অবস্থা |
- প্লাগ লাগানো। Device D+-এ pull-up চালু করে; hub দেখে লাইন উঠেছে, আর host-কে জানায় “নতুন full-speed device”. firmware প্রস্তুত হওয়ার আগে pull-up চালু না করাই নিয়ম।
- Reset. host দুই লাইনই নিচে টেনে (SE0) ১০ ms-এর বেশি reset দেয়। এখন device-এর address 0, যা সব নতুন device-এর সাধারণ ঠিকানা; তাই একসময়ে একটিই enumerate হয়।
- প্রথম প্রশ্ন। 80 = device→host, standard, device-কে; 06 = GET_DESCRIPTOR; wValue 0x0100 = device descriptor; চাওয়া 64 byte. উত্তরের ৮ নম্বর byte bMaxPacketSize0 = 64 জানায় endpoint 0-এর মাপ। Microsoft-এর একটি বর্ণনা অনুযায়ী Windows এভাবে address দেওয়ার আগে পড়ে; USB spec-এর তালিকায় address দেওয়া আগে আসে, তাই host ভেদে ক্রম একটু আলাদা।
- নতুন ঠিকানা। 00 05, wValue 7: SET_ADDRESS 7. এর পরে device শুধু 7-এ সাড়া দেয়। (৭ উদাহরণ; host নিজে বেছে নেয়, ৭ বিটের ঠিকানায় ১২৭টি পর্যন্ত device.)
- পুরো পরিচয়। address 7-এ আবার GET_DESCRIPTOR, এবার ঠিক ১৮ byte (wLength 0x12): vendor ID, product ID, class. তারপর configuration descriptor (প্রথমে ৯ byte, পরে পুরোটা), যেখানে interface আর endpoint-এর তালিকা।
- Configuration বেছে নেওয়া। 00 09 01: SET_CONFIGURATION 1. এখন device “Configured”; কাজের endpoint-গুলো চালু, firmware data পাঠাতে পারে।
- Driver. OS class দেখে নিজের driver বসায়: CDC হলে একটি virtual COM port, HID হলে keyboard বা অন্য input যন্ত্র। বাজারঘরের scale CDC হলে দোকানের কম্পিউটারে terminal-এ দামের লাইন পড়া যায়, কোনো বাড়তি driver ছাড়া।
Stepper-এর SETUP packet আর একটি বানানো device descriptor ব্রাউজারের Python-এ খুলে দেখা যাক (SETUP-এর ক্ষেত্রের মানে beyondlogic-এর “USB in a NutShell” আর USB 2.0-এর অধ্যায় ৯ অনুযায়ী):
# USB enumeration-এর SETUP packet (৮ byte) আর device descriptor (১৮ byte) পড়া
import struct
REQ = {0x00: "GET_STATUS", 0x05: "SET_ADDRESS", 0x06: "GET_DESCRIPTOR",
0x09: "SET_CONFIGURATION"}
DESC = {1: "device", 2: "configuration", 3: "string"}
CLASS = {0x00: "interface-এ বলা", 0x02: "CDC (communications)", 0x03: "HID"}
def setup(hexs):
rt, req, val, idx, ln = struct.unpack("<BBHHH", bytes.fromhex(hexs))
d = "device->host" if rt & 0x80 else "host->device"
typ = ("standard", "class", "vendor", "?")[(rt >> 5) & 3]
what = REQ.get(req, hex(req))
if req == 0x06:
what += f" ({DESC[val >> 8]}, index {val & 0xFF})"
elif req in (0x05, 0x09):
what += f" ({val})"
print(f"{hexs} {d}, {typ}: {what}, wLength={ln}")
for s in ("80 06 00 01 00 00 40 00", "00 05 07 00 00 00 00 00",
"80 06 00 01 00 00 12 00", "80 06 00 02 00 00 09 00",
"00 09 01 00 00 00 00 00"):
setup(s)
# একটি CDC device-এর device descriptor (VID/PID উদাহরণের জন্য বানানো)
dd = bytes.fromhex("12 01 00 02 02 00 00 40 34 12 CD AB 00 01 01 02 03 01")
f = struct.unpack("<BBHBBBBHHHBBBB", dd)
print(f"bLength={f[0]} type={DESC[f[1]]} USB {f[2] >> 8}.{(f[2] >> 4) & 15}"
f" class={CLASS[f[3]]} EP0={f[6]} byte VID=0x{f[7]:04X} PID=0x{f[8]:04X}"
f" configurations={f[13]}")আসল আউটপুট (ব্রাউজারের Python):
80 06 00 01 00 00 40 00 device->host, standard: GET_DESCRIPTOR (device, index 0), wLength=64
00 05 07 00 00 00 00 00 host->device, standard: SET_ADDRESS (7), wLength=0
80 06 00 01 00 00 12 00 device->host, standard: GET_DESCRIPTOR (device, index 0), wLength=18
80 06 00 02 00 00 09 00 device->host, standard: GET_DESCRIPTOR (configuration, index 0), wLength=9
00 09 01 00 00 00 00 00 host->device, standard: SET_CONFIGURATION (1), wLength=0
bLength=18 type=device USB 2.0 class=CDC (communications) EP0=64 byte VID=0x1234 PID=0xABCD configurations=1
SETUP-এর প্রথম byte-এর বিট 7 দিক বলে (1 = device থেকে host), বিট 6–5 ধরন (standard, class, vendor). সব সংখ্যা little-endian: wValue “00 01” মানে 0x0100, descriptor-এর ধরন 1 (device), index 0. Modbus-এর register যেখানে বড় byte আগে, USB সেখানে ছোট byte আগে: দুই protocol একই firmware-এ থাকলে byte-ক্রমের ভুল খুব সহজ। VID 0x1234 আর PID 0xABCD এখানে শুধু উদাহরণের জন্য বানানো; আসল পণ্যে vendor ID আসে USB-IF থেকে।
Class কেন জরুরি? USB-IF-এর তালিকায় CDC-এর class code 0x02, আর HID-এর 0x03 (HID শুধু interface descriptor-এ বসে). OS-গুলোতে এই সাধারণ class-এর driver আগে থেকেই থাকে, তাই এমন device-এর জন্য নিজের driver লিখতে হয় না। তবু নিজের USB device বানানো UART-এর চেয়ে অনেক বেশি কাজ: descriptor, enumeration-এর state, timing-এর কঠোরতা আর chip-এর USB stack. তাই অনেক নকশায় MCU-র UART-এর সঙ্গে একটি USB-UART bridge chip জোড়া হয়, যেটি নিজেই CDC বা vendor-এর driver-এর device; firmware শুধু UART দেখে। গুদামের master-ও এভাবে কম্পিউটারের USB থেকে একটি USB-RS485 adapter দিয়ে bus চালাতে পারে।
৮ · কোনটি কখন — মডিউল ৮-এর সব interface এক টেবিলে
এই মডিউলের সাতটি পর্বে মোট নয়টি interface এলো। নকশার সময় প্রশ্ন একটাই: কয়টি তার, কত দূর, কত দ্রুত, কয়টি যন্ত্র, আর ভুল কে ধরবে। সংখ্যাগুলো “সাধারণ” মান; নির্দিষ্ট chip-এর datasheet সবসময় শেষ কথা।
| Interface (পর্ব) | তার | যন্ত্র আর গঠন | সাধারণ গতি | দূরত্ব | ভুল ধরা | বাজারঘরে বা কোথায় |
|---|---|---|---|---|---|---|
| ADC (৪৭) | এক analog তার + GND | sensor → MCU | sampling rate chip-ভেদে | খুব ছোট, noise-এ নষ্ট | নেই (গড় করা) | scale-এর load cell |
| DAC (৪৮) | এক analog তার + GND | MCU → যন্ত্র | settling time-এ সীমিত | খুব ছোট | নেই | buzzer-এর স্বর বা আলোর মাত্রা |
| UART (৪৯) | TX, RX, GND | দুই পক্ষ, full-duplex | 9600–115200 baud সাধারণ | TTL-এ বোর্ড বা ছোট তার | parity (ঐচ্ছিক) | scale-এর দামের লাইন |
| SPI (৫০) | SCLK, MOSI, MISO + প্রতি যন্ত্রে CS | এক master, অনেক slave | কয়েক MHz থেকে কয়েক দশ MHz | বোর্ডের ভেতরে | নেই | display, flash |
| I2C (৫১) | SDA, SCL (open-drain, pull-up) | ঠিকানা দিয়ে অনেক যন্ত্র | 100 kHz, 400 kHz, 1 MHz | বোর্ডের ভেতরে | শুধু ACK | cold room-এর sensor |
| CAN (৫২) | CAN_H, CAN_L (differential) | multi-master, ID-তে arbitration | classic CAN 1 Mbit/s পর্যন্ত | 1 Mbit/s-এ কয়েক দশ মিটার, গতি কমালে বেশি | CRC-15, ACK, stuffing | গাড়ি, কারখানার যন্ত্র |
| USB (৫৩) | D+, D−, VBUS, GND | host + hub দিয়ে গাছ, ১২৭ device | 1.5 / 12 / 480 Mb/s | কয়েক মিটার | packet-এ CRC, retry | scale থেকে দোকানের কম্পিউটার |
| 1-Wire (৫৩) | DQ + GND | এক master, ROM দিয়ে অনেক slave | প্রতি বিট ≈ 70 µs | কয়েক মিটার, ভালো নকশায় বেশি | ROM-এ CRC-8 | ঠান্ডা ঘরের বাড়তি probe |
| RS-485 + Modbus RTU (৫৩) | A, B, common | এক master, ২৪৭ পর্যন্ত ঠিকানা, ৩২ UL | 9600 বা 19200 baud সাধারণ | 9600 baud-এ 1000 m (Modbus spec) | parity + CRC-16 | গুদামের controller → cold room |
সিদ্ধান্তের একটি সরল পথ: একই বোর্ডে sensor হলে I2C (কম তার) বা SPI (বেশি গতি); কম্পিউটারের সঙ্গে হলে USB, সবচেয়ে সহজে USB-UART bridge দিয়ে; ঘর পেরিয়ে অনেক যন্ত্র আর নিয়মিত প্রশ্ন-উত্তর হলে RS-485 + Modbus; অনেক যন্ত্র নিজে থেকে বার্তা পাঠাবে আর অগ্রাধিকার লাগবে (গাড়ি, মেশিন) হলে CAN; একটি pin-এ কয়েকটি ধীর sensor হলে 1-Wire. আর যন্ত্র যদি তার ছাড়া, ইন্টারনেটে কথা বলবে, তাহলে পরের ধাপ: IoT-এর gateway আর বেতার, পর্ব ৭০ (IoT architecture) আর পর্ব ৭১ (Wi-Fi আর BLE).
আরও গভীরে: Modbus-এর জন্ম ১৯৭৯ সালে Modicon-এর PLC-র জন্য, এমনটাই সাধারণত বলা হয়; spec খোলা থাকায় এটি শিল্পে প্রায় সাধারণ ভাষা হয়ে যায়, আর এখন Modbus Organization এটি দেখে। TCP-তে চলা Modbus/TCP-তে CRC নেই, কারণ TCP নিজেই ভুল ধরে, আর ঠিকানার জায়গায় আসে “unit identifier”. 1-Wire-এর সবচেয়ে চোখে পড়া রূপ iButton: স্টেইনলেস স্টিলের ছোট বোতামে ভরা chip, যার ROM ID দিয়ে দরজার চাবি বা হাজিরা হয়। USB-র সবচেয়ে বড় উদ্ভাবন হয়তো electrical নয়, class: একটি keyboard বা COM port যেকোনো কম্পিউটারে প্রায় সবসময় driver ছাড়া চলে।
পরীক্ষা ও ইন্টারভিউতে:
- Modbus RTU frame-এর অংশ আর সর্বোচ্চ মাপ? address, function code, data, CRC-16 (নিচের byte আগে); সর্বোচ্চ ২৫৬ byte.
- Slave address-এর পরিসর? 1–247; 0 broadcast (উত্তর নেই); 248–255 সংরক্ষিত।
- FC 03-এ register 6 নেই, কী উত্তর? exception:
01 83 02+ CRC, অর্থাৎ ILLEGAL DATA ADDRESS. - RS-485-এ termination কোথায় আর কেন? trunk-এর দুই প্রান্তে, তারের impedance-এর সমান (প্রায় 120 Ω), প্রতিফলন থামাতে; শাখা-তারে নয়।
- USB device enumeration-এর সময় প্রথমে কোন ঠিকানায় সাড়া দেয়? 0, default address; SET_ADDRESS-এর পরে নতুন ঠিকানায়।
৯ · AI-এর যুগে Modbus আর bus-এর কোড যাচাই
AI-কে একটি Modbus RTU master লিখতে বললে সে প্রায় সবসময় চলনসই কোড দেয়, আর টেবিলের ওপর এক slave-এ তা চলেও যায়। ভুলগুলো বেরোয় অন্য যন্ত্রের সঙ্গে, লম্বা তারে বা ধার-ঘেঁষা অবস্থায়। পরিচিত ভুল আর ধরার উপায়:
| AI প্রায়ই যা করে | কীভাবে ধরবেন |
|---|---|
| CRC-এর বড় byte আগে পাঠায়, বা ভুল CRC (CRC-16/CCITT, শুরুর মান 0) | “123456789” → 0x4B37 আর spec-এর 02 07 → 0x1241 test vector চালানো |
| 40001-এর মতো নম্বর সরাসরি frame-এ লেখে, বা এক ঘর সরে যায় | যন্ত্রের manual-এর register map আর PDU ঠিকানা (০ থেকে) মেলানো |
| RS-485-এর DE বন্ধ করে TXE দেখে, ফলে শেষ byte অর্ধেক কেটে যায় | TC (transmission complete) দেখে DE বন্ধ; logic analyzer বা simulator-এ শেষ stop বিট দেখা |
| প্রতিটি যন্ত্রে termination আর bias বসাতে বলে | Modbus spec: termination শুধু দুই প্রান্তে, bias এক জায়গায় |
| 1-Wire-এর delay interrupt চালু রেখে লেখে, বা µs-এর হিসাব ভুল | AN126-এর সময়ের সঙ্গে মেলানো; slot-এর সময় interrupt বন্ধ |
| USB descriptor-এ অন্য কোম্পানির VID বা বানানো class code বসায় | USB-IF-এর class তালিকা; বিক্রির পণ্যে নিজের বৈধ VID |
| Modbus-কে “নিরাপদ” বলে, ইন্টারনেটে খুলে দিতে বলে | Modbus RTU-তে কোনো authentication নেই; আলাদা network আর gateway |
প্রসঙ্গ আর যাচাইয়ের শর্ত শুরুতেই দিন:
AI-এর উত্তর হাতে পেলে — যাচাইয়ের চেকলিস্ট
ভাবনার প্রশ্ন
প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন, তারপর “→ উত্তর” চাপুন।
প্র ০১Modbus ১৯৭০-এর দশকের শেষের protocol, কোনো authentication বা encryption নেই। তবু আজও কারখানা, বিদ্যুৎ-কেন্দ্র আর ভবনের যন্ত্রে এটি সবচেয়ে প্রচলিতগুলোর একটি কেন, আর এর ঝুঁকি কীভাবে সামলাবেন?
সাধারণত বলা হয়, Modicon ১৯৭৯ সালে নিজেদের PLC-র জন্য Modbus বানায়। এর জনপ্রিয়তার মূল কারণ এর সরলতা আর খোলা থাকা। spec বিনামূল্যে পড়া যায়, কোনো লাইসেন্স লাগে না, আর একটি ছোট 8-বিট MCU-ও কয়েকশো লাইনের C-তে একটি slave চালাতে পারে, যেমন এই পর্বের board-এ। ডেটার মডেলও সরল: সব কিছু ১৬ বিটের register বা এক বিটের coil. একটি তাপমাত্রার যন্ত্র, একটি মিটার আর একটি motor drive, ভিন্ন নির্মাতার হলেও, একই master একই ভাষায় পড়তে পারে। শিল্পে যন্ত্রের আয়ু কয়েক দশক, তাই একবার কোনো ভাষা চালু হলে তা সহজে বদলায় না; নতুন যন্ত্রও পুরোনোগুলোর সঙ্গে কথা বলতে Modbus রাখে।
কিন্তু Modbus নকশা হয়েছিল এমন এক জগতের জন্য যেখানে তার কারখানার ভেতরে, আর তারে হাত দিতে পারে শুধু কর্মীরা। এতে কোনো পরিচয় যাচাই নেই: bus-এ পৌঁছাতে পারলে যে কেউ FC 06 দিয়ে একটি limit বদলাতে পারে, যেমন আমাদের run-এ master high limit 800 থেকে 1000 করেছে, আর slave প্রশ্ন ছাড়াই মেনেছে। CRC এখানে কোনো রক্ষা নয়: CRC শুধু দুর্ঘটনাজনিত ভুল ধরে, আর যে কেউ সঠিক CRC নিজে হিসাব করতে পারে। Modbus/TCP এসে বিপদ বাড়িয়েছে, কারণ একই নিয়ম এখন IP network-এ, আর ভুল কনফিগারেশনে ইন্টারনেট থেকেও পৌঁছানো যায়।
রক্ষার পথ তাই নকশার স্তরে, protocol-এর ভেতরে নয়। Modbus-এর bus আর network আলাদা রাখা, অফিস বা ইন্টারনেট থেকে সরাসরি পথ না রাখা; বাইরে data নিতে একটি gateway, যা শুধু পড়ার অনুমতি দেয় আর নিজে নিরাপদ protocol-এ (যেমন TLS-সহ MQTT, পর্ব ৭৩) cloud-এ পাঠায়। slave-এর firmware-এ যুক্তির পরীক্ষা: অসম্ভব limit (high-এর চেয়ে বড় low) মেনে না নেওয়া, গুরুত্বপূর্ণ register বদলালে log রাখা। Modbus Organization TLS-ভিত্তিক একটি নিরাপদ Modbus/TCP-এর spec-ও প্রকাশ করেছে বলে জানা যায়, তবে পুরোনো যন্ত্রে তা থাকে না। Cybersecurity-র IoT নিরাপত্তার পর্বে এই ধরনের network-ভাগের নীতি বিস্তারিত।
মূল উপলব্ধি: Modbus টিকে আছে সরলতা আর খোলা মানের জন্য; সেই সরলতার দামই নিরাপত্তার অভাব, তাই রক্ষা আসে আলাদা network, gateway আর firmware-এর যুক্তি-পরীক্ষা থেকে।
প্র ০২RS-485-এর receiver মাত্র 200 mV-এর পার্থক্য বোঝে, আর −7 থেকে +12 V-এর common-mode সহ্য করে। এই দুটি সংখ্যা মিলিয়ে কেন এটি কারখানার জন্য আদর্শ, আর কোথায় এর সীমা?
একটি TTL UART-এর গ্রাহক লাইনের ভোল্টেজ মাপে নিজের ground থেকে। মোটর চালু হলে তারে কয়েকশো mV-এর noise ঢুকতে পারে, আর দুই যন্ত্রের ground-এর মধ্যেও কিছু পার্থক্য থাকে; 3.3 V-এর logic-এ এগুলো সহজে ভুল বিট বানায়। RS-485 দুটি জিনিস একসাথে করে। Driver দুই তারে উল্টো সংকেত দেয়, অন্তত 1.5 V পার্থক্য 54 Ω-এর ভারে (দুই প্রান্তের 120 Ω আর বাকি যন্ত্রের ভার মিলিয়ে); আর receiver শুধু পার্থক্য দেখে, 200 mV-এর বেশি হলেই সিদ্ধান্ত। ফলে তারের ক্ষয়ে সংকেত সাত ভাগের এক ভাগে নামলেও পড়া যায়। twisted pair-এর দুই তার পাশাপাশি পেঁচানো, তাই বাইরের noise দুটিতে প্রায় সমান ঢোকে; পার্থক্যে তা বাদ যায়।
Common-mode পরিসর দ্বিতীয় রক্ষা। দুই তারের গড় ভোল্টেজ, অর্থাৎ দুই যন্ত্রের ground-এর পার্থক্য আর সমান-ঢোকা noise মিলিয়ে, −7 থেকে +12 V-এর মধ্যে থাকলে receiver ঠিক কাজ করে। একটি বড় গুদামে, যেখানে অফিস আর ঠান্ডা ঘর আলাদা লাইনে, কয়েক ভোল্টের ground-পার্থক্য অস্বাভাবিক নয়; TTL সেখানে অচল, RS-485 চলে।
সীমা তিনটি। প্রথম, গতি আর দূরত্ব একসাথে নয়: TI-এর guide-এর হিসাবে 100 kbps-এ প্রায় 1200 m, আর তারের দৈর্ঘ্য (m) × গতি (bps) মোটামুটি 107-এর নিচে রাখার একটি সতর্ক নিয়ম আছে। দ্বিতীয়, common-mode-এর বাইরে গেলে, যেমন বজ্রপাতের কাছাকাছি বা ভুল ground-এ, transceiver নষ্ট হয়; সেখানে isolated transceiver বা surge সুরক্ষা লাগে। তৃতীয়, ভার: স্ট্যান্ডার্ড driver ৩২ unit load চালায়; ⅛ UL-এর আধুনিক transceiver-এ ২৫৬টি পর্যন্ত, কিন্তু failsafe bias নিজেও ভার যোগ করে (TI প্রায় ২০ UL ধরে), তাই যন্ত্রের সংখ্যা কমে। Modbus spec-ও বলে bias থাকলে অনুমোদিত যন্ত্র চারটি কমে।
মূল উপলব্ধি: ছোট পার্থক্য-সীমা noise আর ক্ষয় সামলায়, বড় common-mode পরিসর ground-এর পার্থক্য সামলায়; তবু গতি-দূরত্ব, ভার আর বৈদ্যুতিক সুরক্ষার হিসাব নকশাকারীর দায়িত্ব।
প্র ০৩1-Wire-এ এক তারেই data, আর কিছু chip-এ সেই তার থেকেই শক্তি। এই নকশার সুবিধা কী, আর লম্বা তারে বা অনেক sensor-এ কী সমস্যা হয়?
1-Wire-এর মূল চিন্তা হলো তার আর pin বাঁচানো। একটি GPIO আর একটি pull-up দিয়ে একই তারে কয়েক ডজন sensor রাখা যায়, কারণ প্রতিটির কারখানায় লেখা ৬৪ বিটের অনন্য ROM code আছে। master “Search ROM” নামের একটি বিট-ধরে খোঁজার পদ্ধতিতে সবার ID বের করে, তারপর ID ধরে একজনকে ডাকে। ঠান্ডা ঘরে কয়েকটি তাক জুড়ে কয়েকটি DS18B20 রাখলে একটি তারেই সব তাপমাত্রা আসে, আর ROM-এর CRC-8 (এই পর্বের মডেলে যাচাই করা) বলে ID ঠিক পড়া হয়েছে কি না।
Parasitic power আরও এক ধাপ এগোয়: chip-এর ভেতরে একটি ছোট capacitor, লাইন উঁচু থাকার সময় চার্জ হয়, আর লাইন নিচে থাকার সময় chip সেই চার্জে চলে। তখন তার লাগে মাত্র দুটি, data আর ground. কিন্তু বেশি স্রোতের কাজে, যেমন DS18B20-এর তাপমাত্রা রূপান্তর বা EEPROM-এ লেখা, সেই চার্জ যথেষ্ট নয়; datasheet তখন master-কে একটি শক্ত pull-up (সাধারণত একটি MOSFET দিয়ে) কিছু সময়ের জন্য চালু রাখতে বলে, আর সেই সময় bus-এ অন্য কাজ চলে না।
লম্বা তার আর অনেক sensor-এ সমস্যা আসে সময় থেকে। তারের capacitance বাড়লে pull-up লাইন ধীরে তোলে; 6 µs-এর একটি “1” যখন ছাড়া হয়, লাইন যদি sample-এর সময়ের আগে উঠতে না পারে, slave “0” পড়ে। প্রতিটি sensor-এর ভারও যোগ হয়। তাই লম্বা bus-এ ছোট pull-up resistor, তারকা-আকৃতির বদলে একটানা লাইন, আর কখনো বিশেষ driver chip লাগে; Maxim-এর app note-গুলো লম্বা 1-Wire network-এর আলাদা নকশা-নির্দেশ দেয়। Firmware-এর দিক থেকে কঠোর µs-এর সময় মানে interrupt-এর সঙ্গে টানাটানি: সমাধান ছোট critical section, বা UART বা timer দিয়ে waveform বানানো।
মূল উপলব্ধি: 1-Wire কম তার আর অনন্য ID দিয়ে সস্তায় অনেক sensor জোড়ে, কিন্তু দাম দেয় গতিতে, সময়ের কঠোরতায় আর লম্বা তারের সংবেদনশীলতায়।
প্র ০৪বাজারঘরের scale-কে কম্পিউটারের সঙ্গে জুড়তে দুটি পথ: MCU-র ভেতরের USB-তে নিজের CDC device বানানো, অথবা UART-এর সঙ্গে একটি USB-UART bridge chip. কোনটি কখন বেছে নেবেন?
USB ১৯৯০-এর দশকের মাঝামাঝি এসেছিল পুরোনো serial, parallel আর keyboard port-এর জঙ্গল সরাতে, একটি প্লাগে সব। সেই সুবিধার পেছনে device-এর অনেক দায়িত্ব। নিজের USB device মানে firmware-কে enumeration-এর পুরো কথোপকথন সামলাতে হবে: reset-এর পরে address 0-তে সাড়া, descriptor-এর সঠিক মাপ আর ক্রম, SET_ADDRESS-এর পরে ঠিক সময়ে নতুন ঠিকানায় যাওয়া, endpoint-এর buffer আর host-এর সময়সীমা মানা। এর জন্য সাধারণত chip-নির্মাতার USB stack লাগে, আর code ও RAM-এর একটি বড় অংশ সেখানে যায়। বিক্রির পণ্যে একটি বৈধ vendor ID-ও লাগে, আর অনেক ক্ষেত্রে সামঞ্জস্যের পরীক্ষা।
বিনিময়ে লাভও আছে। একটি chip কম, তাই বোর্ড ছোট; data-র গতি UART-এর baud-এ আটকে থাকে না; একই USB-তে একসাথে CDC আর অন্য interface (যেমন firmware update-এর জন্য) রাখা যায়; আর device নিজের নাম ও serial নম্বর দিয়ে নিজেকে চেনায়। HID class নিলে কিছু OS-এ driver-এর ঝামেলা আরও কম, যদিও HID-এর data packet ছোট আর নিয়ম আলাদা।
Bridge chip উল্টো দিক থেকে ভাবে: সব USB-র জটিলতা chip-নির্মাতা আগেই সমাধান করেছেন, firmware শুধু পর্ব ৪৯-এর UART দেখে। নতুন দল, ছোট MCU (যার ভেতরে USB নেই), বা দ্রুত বাজারে আসার দরকার হলে এটিই প্রায়ই সঠিক। প্রোটোটাইপের সময় debug-ও সহজ, কারণ UART লাইন logic analyzer-এ সরাসরি পড়া যায়। খরচ: বোর্ডে একটি বাড়তি chip, আর কিছু chip-এর জন্য OS-এ নির্মাতার driver.
বাজারঘরের scale-এর ক্ষেত্রে, যেখানে একটি দামের লাইন প্রতি 100 ms-এ যায় আর গতির কোনো চাপ নেই, bridge-এর পথই সরল ও নিরাপদ। হাজার হাজার ইউনিট তৈরি হলে, আর MCU-তে USB আগে থেকেই থাকলে, নিজের CDC device বানানো বোর্ড আর জটিলতার হিসাবে যুক্তিসংগত হতে পারে।
মূল উপলব্ধি: USB-র জটিলতা কোথাও না কোথাও সামলাতে হয়; প্রশ্ন শুধু কে সামলাবে, আপনার firmware না একটি তৈরি bridge chip.
প্র ০৫CRC-16 এই পর্বের পরীক্ষায় সব এক-বিটের ভুল আর byte-এর ক্রম-বদল ধরেছে। তাহলে কি CRC সঠিক frame-এর নিশ্চয়তা দেয়? কী ধরে না, আর কেন CRC নিরাপত্তা নয়?
CRC-এর শক্তি তার গণিতে। বার্তাকে একটি বড় polynomial ধরে generator দিয়ে ভাগ করলে ভাগশেষ ১৬ বিট; ভালো generator-এ কিছু ধরনের ভুল নিশ্চিতভাবে ধরা পড়ে: সব এক-বিটের ভুল, আর ১৬ বিট বা তার কম লম্বা যেকোনো burst ভুল (পাশাপাশি অনেক বিট নষ্ট হওয়া, যা মোটরের spike-এ সাধারণ). এই পর্বের C কোডে ৪৮টি এক-বিটের ভুলের সবকটি ধরা পড়েছে, আর XOR checksum যেখানে 03 E8 আর E8 03-কে আলাদা করতে পারেনি, CRC পেরেছে।
কিন্তু নিশ্চয়তা নয়। এলোমেলো বড় ভুলে একটি নষ্ট frame-এর CRC কাকতালীয়ভাবে মিলে যাওয়ার সম্ভাবনা মোটামুটি ৬৫,৫৩৬-এ এক। তার ওপর কিছু ভুল CRC-এর দৃষ্টির বাইরে: পুরো frame হারিয়ে যাওয়া (তখন timeout ধরে), পুরোনো কিন্তু সঠিক frame আবার আসা, বা frame-এর সীমানা ভুল বোঝা (t3.5-এর হিসাব ভুল হলে দুটি frame জুড়ে যেতে পারে, আর বিরল ক্ষেত্রে জোড়া অংশের CRC মিলে যেতে পারে)। তাই Modbus-এ CRC-এর ওপরে আরও স্তর: প্রতি অক্ষরে parity, slave-এর ঠিকানা মেলানো, উত্তরের function code আর byte count মেলানো, master-এর timeout আর retry.
নিরাপত্তার প্রশ্নে CRC কিছুই করে না। CRC গোপন নয়; polynomial সবার জানা, আর যে কেউ একটি frame বানিয়ে সঠিক CRC জুড়ে দিতে পারে, যেমন আমরা এই পর্বে করেছি। একজন আক্রমণকারী তাই সহজে “বৈধ” frame পাঠাতে পারে। ইচ্ছাকৃত বদল ধরতে লাগে একটি গোপন চাবিনির্ভর message authentication code (যেমন HMAC) বা digital signature, যার কথা পর্ব ৭৭-এ firmware update-এর প্রসঙ্গে আসবে। পর্ব ৫২-এর CAN-ও CRC ব্যবহার করে, আর একই কারণে গাড়ির network-এ নিরাপত্তার জন্য আলাদা ব্যবস্থা লাগে।
মূল উপলব্ধি: CRC দুর্ঘটনার ভুল ধরার জন্য দারুণ, কিন্তু নিখুঁত নয় আর শত্রুর বিরুদ্ধে অকেজো; নির্ভরযোগ্যতার জন্য স্তর, নিরাপত্তার জন্য cryptography.
অনুশীলন
নিজে আগে চেষ্টা করুন, তারপর উত্তর খুলে মেলান।
-
নকশা — master-এর লেখার অনুরোধ: গুদামের controller-এর firmware-এর জন্য C-তে দুটি function লিখুন:
mb_write_req(addr, reg, value, out[8]), যা FC 06-এর পুরো RTU frame বানায় (CRC সহ), আরmb_write_ok(req, rep, n), যা উত্তর ঠিক কি না বলে। cold room-এর low limit −1.00 °C করতে (slave 1, register 3) কোন ৮ byte যাবে?void mb_write_req(uint8_t addr, uint16_t reg, int16_t value, uint8_t out[8]) { uint16_t v = (uint16_t)value; out[0] = addr; out[1] = 0x06; out[2] = (uint8_t)(reg >> 8); out[3] = (uint8_t)(reg & 0xFF); /* big-endian */ out[4] = (uint8_t)(v >> 8); out[5] = (uint8_t)(v & 0xFF); uint16_t c = crc16(out, 6); out[6] = (uint8_t)(c & 0xFF); out[7] = (uint8_t)(c >> 8); /* CRC low first */ } int mb_write_ok(const uint8_t req[8], const uint8_t *rep, uint32_t n) { return n == 8 && crc16(rep, n) == 0 && memcmp(req, rep, 8) == 0; }−1.00 °C × 100 = −100 = 0xFF9C (two's complement). frame:
01 06 00 03 FF 9C 38 53. স্বাভাবিক উত্তর এই ৮ byte-এর হুবহু echo, তাই তুলনা যথেষ্ট; exception হলে (যেমন01 86 02 C3 A1) দৈর্ঘ্য ৫, ফল 0. আমার lab-এরpa1.c-তে Clang 22.1.8-এ-Wall -Wextra -Wconversion-এ কোনো warning ছাড়া compile করে চালানো:01 06 00 03 FF 9C 38 53,ok=1, exception-এok=0.crc16এই পর্বের firmware-এর ফাংশন। বাস্তব master-এ এর সঙ্গে response timeout আর সীমিত retry লাগবে। -
ভুল খুঁজুন — চুপ করে থাকা slave: একজন নিজের master-এর কোডে CRC লিখলেন
out[6] = c >> 8; out[7] = c & 0xFF;. slave 1-এর register 0 আর 1 পড়ার অনুরোধ পাঠালে তারে যায়01 03 00 00 00 02 0B C4, আর slave কখনো উত্তর দেয় না। ভুলটি কী, slave ঠিক কী দেখে, আর কোনো exception কেন আসে না?CRC = 0x0BC4, আর Modbus-এ নিচের byte (C4) আগে যাওয়ার কথা; এখানে উল্টো। slave পুরো ৮ byte-এর CRC নিয়ে 0 আশা করে, কিন্তু পায় 0xA415 (আমার lab-এর
practice.py-তে হিসাব করা). তার কাছে এটি নষ্ট frame, আর নষ্ট frame-এ spec অনুযায়ী slave কোনো উত্তরই দেয় না: exception দিতে হলে আগে নিশ্চিত হতে হয় frame-টি সত্যিই তার জন্য, যা CRC ছাড়া জানা যায় না। ফলে master শুধু timeout দেখে, যা দেখতে তার কাটা বা ভুল baud-এর মতো, তাই এই bug সময় নষ্ট করে। সমাধান: byte দুটি অদলবদল; আর ধরার উপায়: পাঠানো frame-এর CRC নিজেই আবার হিসাব করে 0 পাওয়া যায় কি না দেখা, বা board-এর মতো একটি simulator-এ পরিচিত frame01 03 00 00 00 02 C4 0B-এর সঙ্গে মেলানো। -
হিসাব — poll-এর সময় আর 1-Wire: (ক) 19200 baud, 8E1-এ master ১০টি slave-এর প্রতিটি থেকে ২টি register পড়ে। slave-এর ভাবার সময় বাদ দিলে একটি পুরো চক্র অন্তত কত ms? (খ) একই bus-এ 9600 baud-এ একটি slave থেকে ছয়টি register পড়লে? (গ) 1-Wire-এ AN126-এর সময়ে reset আর Read ROM (কমান্ড + ৮ byte) কত সময় নেয়?
(ক) এক অক্ষর = 11 ÷ 19200 s = 0.573 ms; t3.5 = 3.5 × 0.573 = 2.005 ms. প্রশ্ন ৮ byte, উত্তর ৯ byte (1 + 1 + 1 + 4 + 2): ১৭ × 0.573 = 9.74 ms, আর দুটি নীরবতা 4.01 ms, মোট 13.75 ms প্রতি slave; ১০টিতে 137.5 ms. (খ) উত্তর এখন 5 + 12 = ১৭ byte, প্রশ্ন ৮: ২৫ অক্ষর × 1.146 ms + 2 × 4.010 ms = 36.67 ms. (গ) reset 480 + 70 + 410 = 960 µs; তারপর ৯ byte × ৮ বিট × 70 µs = 5040 µs; মোট 6000 µs = 6.0 ms. (ক) আর (গ) এই পর্বের দুটি Python ব্লকের আউটপুটেই আছে, (খ) আমার lab-এর
practice.py-তে মেলানো। -
আগে বলুন — একটি উত্তর পড়া: master cold room-কে (slave 1) register 0 থেকে ২টি পড়তে বলল, আর পেল
01 03 04 FF CE 00 02 2A 19. CRC ঠিক কি না, তাপমাত্রা কত, alarm কোন অবস্থায়? README-র নিয়ম মেনে এই অবস্থায় যাওয়ার জন্য আগে কী ঘটতে হয়েছে?প্রথম সাত byte-এর CRC = 0x192A, তারে
2A 19: ঠিক (আমার lab-এরpractice.py-তে বানানো ও যাচাই করা). byte count 4. reg 0 = 0xFFCE, signed ১৬ বিটে −50, অর্থাৎ −0.50 °C. reg 1 = 2: alarm LOW. README-র নিয়মে LOW alarm-এর জন্য পরপর তিনটি reading 0.00 °C-এর নিচে লাগে; reference-এরcoldroom.c-এর run-এ ঠিক এটি ঘটে, 15, 16, 17 s-এ −0.50 °C, আর 17 s-এ “ALARM ON: LOW”. এখানে byte-গুলোকে unsigned ধরলে 65486 পাওয়া যেত, 654.86 °C: Modbus register-কে signed না unsigned পড়তে হবে, তা যন্ত্রের register map বলে, protocol বলে না।
নিজেকে যাচাই করুন
ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।
ক্রমএকটি full-speed USB device কম্পিউটারে লাগানো হলো। enumeration-এর ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)
- Device D+-এ pull-up চালু করে, hub নতুন device টের পায়
- Host port-টিকে reset করে, device address 0-তে সাড়া দেয়
- Host address 0-তে device descriptor চেয়ে endpoint 0-এর মাপ জানে
- Host SET_ADDRESS দিয়ে নতুন ঠিকানা দেয়
- Host নতুন ঠিকানায় পুরো device আর configuration descriptor পড়ে
- SET_CONFIGURATION-এর পরে OS class দেখে driver বসায়
একটি Modbus RTU frame-এর ছয় byte 01 03 00 00 00 02-এর CRC-16 হলো 0x0BC4. তারে frame-এর শেষ দুই byte কী হবে?
0B C4C4 0B00 00D0 23
একটি Modbus slave-এ মাত্র ৬টি holding register (ঠিকানা 0 থেকে 5). master FC 03-এ শুরু 6, সংখ্যা 1 চাইল, CRC ঠিক। slave 1 কী পাঠাবে?
- কিছুই না, master-এর timeout হবে
01 83 01+ CRC01 83 03+ CRC01 83 02+ CRC
একটি ৮০০ m লম্বা RS-485 trunk-এ ১০টি যন্ত্র। termination resistor কোথায় বসবে?
- প্রতিটি যন্ত্রে একটি করে
- শুধু master-এর কাছে
- trunk-এর দুই প্রান্তে, প্রায় 120 Ω
- প্রতিটি শাখা-তারের মাথায়
1-Wire-এ master 480 µs reset pulse দিয়ে লাইন ছেড়ে দিল, আর ৭০ µs পরে লাইন পড়ে 0 পেল। এর মানে কী?
- অন্তত একটি 1-Wire device bus-এ আছে
- Bus-এ কোনো device নেই
- ঠিক একটি device আছে
- লাইনে শর্ট, সব কাজ বন্ধ করতে হবে
USB-তে নতুন লাগানো একটি device reset-এর পরে, SET_ADDRESS পাওয়ার আগে, কোন ঠিকানায় host-এর প্রশ্নে সাড়া দেয়?
- 127
- 0
- নিজের vendor ID-র শেষ ৭ বিট
- যে hub port-এ লাগানো, তার নম্বর
RS-485 half-duplex bus-এ একটি MCU-র firmware নিজের উত্তর পাঠিয়ে transceiver-এর DE (driver enable) বন্ধ করবে। কখন বন্ধ করা ঠিক?
- শেষ byte data register-এ লেখার সঙ্গে সঙ্গে
- TXE (transmit data register empty) ওঠার সঙ্গে সঙ্গে
- নিরাপদে থাকতে উত্তর পাঠানোর পরে এক সেকেন্ড অপেক্ষা করে
- TC (transmission complete) ওঠার পরে
শব্দকোষ
লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:
মনে রাখুন
- RS-485: differential A/B + common, driver ≥ 1.5 V, receiver 200 mV, −7 থেকে +12 V; half-duplex, ৩২ UL; termination শুধু দুই প্রান্তে, bias এক জায়গায়; DE বন্ধ TC-এর পরে।
- Modbus RTU: master-slave; ঠিকানা 1–247, 0 broadcast; frame = addr + FC + data + CRC (নিচের byte আগে), ≤ ২৫৬ byte; সীমানা t3.5-এর নীরবতা; register big-endian, 40001 = PDU ঠিকানা 0.
- FC আর exception: 03 পড়া (১–১২৫টি), 06 লেখা (echo); ভুলে FC + 0x80 আর কোড 01, 02, 03, 04; CRC ভুল, অন্য ঠিকানা বা broadcast হলে কোনো উত্তর নেই।
- CRC: CRC-16/MODBUS = শুরু 0xFFFF, 0xA001, ডানে সরানো; test vector “123456789” → 0x4B37, 02 07 → 0x1241. 1-Wire-এর CRC-8: AN27-এর ROM → 0xA2. CRC নিরাপত্তা নয়।
- 1-Wire আর USB: 1-Wire: reset 480 µs, presence 60–240 µs, 70 µs-এর slot, ৬৪ বিটের ROM. USB: host-চালিত; reset → address 0 → descriptor → SET_ADDRESS → SET_CONFIGURATION; CDC (0x02) আর HID (0x03) driver ছাড়া চলে।
আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ
- মাইক্রোপ্রসেসর, এমবেডেড সিস্টেম ও IoT · কোর্স হোম৮৫টি পর্বপুরো কোর্সের মানচিত্র আর বাজারঘরের দুটি device-এর পথ।
- পর্ব ৪৯ · UART — baud rate, frame, parity আর ring bufferআগের ভিত্তিRS-485 আর Modbus RTU-র নিচের frame, TC flag আর ring buffer.
- পর্ব ৪১ · GPIO — input, output, pull-up, pull-down আর open-drainআগের ভিত্তি1-Wire-এর open-drain লাইন আর pull-up.
- পর্ব ৪৩ · Interrupt আর ISR নকশাআগের ভিত্তিRX ISR, critical section আর সময়-বাঁধা কাজ।
- Computer Networks পর্ব ০৯ · Error detectionপাশের ট্র্যাকParity, checksum আর CRC-এর গণিত।
- Computer Architecture পর্ব ৫১ · I/O আর busপাশের ট্র্যাকUSB আর PCIe-এর architecture-স্তরের ছবি।