এই পর্বে যা শিখবেন
- Differential জোড়া তার, dominant আর recessive অবস্থা, termination আর bit rate বনাম তারের দৈর্ঘ্যের সম্পর্ক বোঝা
- Standard আর extended data frame-এর প্রতিটি field চেনা, আর একটি frame বিট ধরে বানিয়ে CRC-15 আর bit stuffing হিসাব করা
- ID-ভিত্তিক bitwise arbitration ধাপে ধাপে চালিয়ে কে জিতবে আর কখন, তা আগেই বলতে পারা
- Frame-এর সময়, bus load আর সবচেয়ে জরুরি বার্তার সবচেয়ে খারাপ অপেক্ষা হিসাব করা
- Error frame, TEC/REC-এর নিয়ম, error-passive আর bus-off বোঝা, আর বাজারঘরের cold-storage গুদামের জন্য একটি CAN নকশা দাঁড় করানো
১ · CAN কেন — গাড়ির তারের জঙ্গল থেকে এক জোড়া তার
১৯৮০-এর দশকের শুরুতে গাড়িতে ইলেকট্রনিক নিয়ন্ত্রণ দ্রুত বাড়ছিল: engine, gearbox, ABS ব্রেক, পরে airbag আর দরজার জানালা। প্রতিটির নিজের ছোট কম্পিউটার, যার নাম ECU (electronic control unit). দুটি ECU-র মধ্যে প্রতিটি সংকেতের জন্য আলাদা তার টানলে তারের গুচ্ছ (wiring harness) ভারী, দামি আর ভুলপ্রবণ হয়ে ওঠে। Bosch ১৯৮৩ সালে এর সমাধান খুঁজতে শুরু করে, আর ১৯৮৬ সালে Detroit-এ SAE-র একটি সম্মেলনে CAN (Controller Area Network) উপস্থাপন করে। মূল ভাবনা: সব ECU একটি জোড়া তারে বসবে, আর সেই তারে বার্তা চলবে।
UART দুই প্রান্তের সরাসরি সংযোগ, I2C আর SPI-তে সাধারণত একটি master বাকিদের ঠিকানা ধরে ডাকে (পর্ব ৪৯, ৫০ আর ৫১)। CAN তিনটি জায়গায় আলাদা:
- Multi-master: কোনো একক নিয়ন্ত্রক নেই। Bus খালি থাকলে যেকোনো node পাঠাতে পারে।
- বার্তা-ভিত্তিক: Frame-এ প্রাপকের ঠিকানা থাকে না, থাকে একটি identifier (ID), যা বলে বার্তার বিষয় কী (“ঘর ১-এর তাপমাত্রা”) আর তার অগ্রাধিকার কত। ID যত ছোট, বার্তা তত জরুরি।
- সবাই শোনে: প্রতিটি frame bus-এর সব node পায়। প্রতিটি node-এর CAN controller একটি filter দিয়ে ঠিক করে কোন ID রাখবে, আর বাকিগুলো CPU-কে না জানিয়েই ফেলে দেয়।
উপমা — রেলস্টেশনের ঘোষণা আর বাসের ঘণ্টার দড়ি: স্টেশনের মাইকে “চট্টগ্রামগামী সুবর্ণ এক্সপ্রেস ৩ নম্বর প্ল্যাটফর্মে” বললে সবাই শোনে, কিন্তু শুধু সেই ট্রেনের যাত্রীরা ওঠেন; ঘোষক কারও নাম ধরে ডাকেন না। CAN-এর ID ঠিক এমন: বার্তার বিষয়, প্রাপকের নাম নয়। আর তারের নিয়মটি পুরোনো বাসের ঘণ্টার দড়ির মতো: যেকোনো একজন যাত্রী টানলেই ঘণ্টা বাজে, আর অন্য কেউ “না টেনে” সেটি থামাতে পারেন না। টানা অবস্থা জোরালো (dominant), ছেড়ে রাখা অবস্থা দুর্বল (recessive).
ইতিহাস এক নজরে: Bosch-এর কাজ শুরু ১৯৮৩; উপস্থাপন ১৯৮৬ (SAE, Detroit); প্রথম CAN controller chip ১৯৮৭ সালে Intel, তার অল্প পরে Philips (প্রচলিত বর্ণনা)। প্রথম যে উৎপাদিত গাড়িতে CAN-ভিত্তিক তারের ব্যবস্থা ছিল বলে সাধারণত বলা হয়, তা ১৯৯১ সালের Mercedes-Benz W140. একই ১৯৯১ সালের সেপ্টেম্বরে Bosch-এর CAN Specification 2.0 বের হয়: Part A-তে ১১ বিটের ID, Part B-তে ২৯ বিটের ID-ও। ISO 11898 মান আসে ১৯৯৩ সালে; Bosch CAN FD 1.0 প্রকাশ করে ২০১২ সালে, আর CAN FD ISO 11898-1:2015-এ যুক্ত হয়।
বাজারঘরের cold-storage গুদাম — এই পর্বের উদাহরণ
বাজারঘরের cold-storage monitor এখন পর্যন্ত একটি ঘরের জন্য একটি device: I2C-র তাপমাত্রা sensor, 8.00 °C-এর ওপরে বা 0.00 °C-এর নিচে পরপর তিনটি reading-এ alarm, প্রতি 1 s-এ একটি reading. ধরা যাক বাজারঘর একটি কাল্পনিক বড় গুদাম চালায়, যেখানে তিনটি ঠান্ডা ঘর আর একটি compressor. প্রতিটি ঘরে একটি তাপমাত্রা node (T1, T2, T3), একটি compressor controller (COMP), আর একটি gateway (G), যা CAN থেকে বার্তা নিয়ে MQTT-তে dashboard-এ পাঠায় (পর্ব ৭৩). এক জোড়া তার পুরো গুদাম ঘুরে আসে। ID ঠিক করা মানেই অগ্রাধিকার ঠিক করা:
| ID | পাঠায় | বার্তা | Data | কত ঘন ঘন |
|---|---|---|---|---|
| 0x051–0x053 | T1–T3 | Alarm চালু বা বন্ধ (সবচেয়ে জরুরি) | 1 byte | অবস্থা বদলালে |
| 0x101–0x103 | T1–T3 | তাপমাত্রা, TMP102-ধাঁচের ১৬ বিট (README-র মতো: 4.00 °C = 0x0400) | 2 byte | প্রতি 1 s |
| 0x200 | COMP | Compressor চলছে কি না | 1 byte | প্রতি 1 s |
এই পর্বে hex লেখা হবে C-ধাঁচে (0x101), আর বিটের সারি বাঁ থেকে ডানে, যে ক্রমে তারে যায় (CAN-এ ID আর data দুটোই আগে MSB পাঠায়)। বিটের index শূন্য থেকে গোনা হবে, SOF = বিট 0.
Board-এর সীমা: কোর্সের বাজারঘর board (BG-M3) একটি virtual Cortex-M3, আসল কোনো পণ্য নয় (পর্ব ০৬)। এর README-র memory map-এ GPIO, SysTick, UART, ADC, I2C-ধাঁচের bus, EXTI আর watchdog আছে; CAN controller নেই. তাই এই পর্বে CAN শেখানো হবে Bosch CAN 2.0 আর ISO 11898-এর বর্ণনা থেকে, Python-এ বানানো মডেল দিয়ে (frame, CRC, stuffing, arbitration, error counter), আর একটি সত্যিকারের cross-check হিসেবে: একই CRC আর stuffing-এর C কোড Clang দিয়ে compile করে board-এ চালানো।
২ · তারের ভাষা — differential জোড়া, dominant আর recessive
সবচেয়ে প্রচলিত রূপ, ISO 11898-2-এর high-speed CAN, দুটি পেঁচানো তার ব্যবহার করে: CAN_H আর CAN_L (twisted pair). তথ্য থাকে দুই তারের পার্থক্যে, কোনো একটির মানে নয়। এই কৌশলের নাম differential signaling: গাড়ির motor বা গুদামের compressor-এর বৈদ্যুতিক noise দুই তারে প্রায় সমানভাবে ঢোকে, আর পার্থক্য নিলে তা বাদ পড়ে যায়।
- Recessive (logic 1): কেউ তার চালাচ্ছে না। Termination resistor দুই তারকে একই voltage-এ (সাধারণত প্রায় 2.5 V) টেনে রাখে; পার্থক্য প্রায় 0 V.
- Dominant (logic 0): কোনো node-এর transceiver CAN_H-কে প্রায় 3.5 V-এর দিকে আর CAN_L-কে প্রায় 1.5 V-এর দিকে ঠেলে; পার্থক্য nominal 2 V. গ্রাহক সাধারণত 0.5 V-এর কম পার্থক্যকে recessive আর প্রায় 0.9 V-এর বেশিকে dominant ধরে (মানের সঠিক সীমা transceiver-এর datasheet-এ দেখুন)।
এখানেই পর্ব ৪১-এর open-drain output আর wired-AND-এর সঙ্গে মিল। সেখানে pull-up তারকে 1-এ রাখে, যেকোনো একটি output 0-তে টানলে পুরো তার 0. CAN-এ termination হলো সেই “pull-up”-এর ভূমিকায়, আর transceiver-এর driver কেবল dominant অবস্থা জোর করে আনতে পারে, recessive আনতে পারে না। তাই তারের মান = সব node-এর পাঠানো বিটের AND: একজনও 0 পাঠালে তারে 0. Arbitration, ACK আর error flag, তিনটিই এই নিয়মের ওপর চলে।
ছবি ৫২.১ — বাজারঘরের গুদামের CAN bus
পাঁচটি node এক জোড়া তারে; দুই প্রান্তে 120 Ω terminator
ছবি ৫২.২ — Recessive আর dominant বিটে দুই তারের voltage
বিটের সারি 1 0 1 0 0 1; high-speed CAN-এর nominal মান
Termination আর তারের দৈর্ঘ্য
প্রতিটি প্রান্তে একটি 120 Ω resistor, যার নাম termination, দুটি কাজ করে: recessive অবস্থায় দুই তারকে সমান করে টেনে আনা, আর তারের শেষে সংকেতের প্রতিফলন (reflection) থামানো, কারণ high-speed CAN-এর twisted pair-এর characteristic impedance-ও nominal 120 Ω. দুটি 120 Ω সমান্তরালে 60 Ω. মেরামতের একটি পুরোনো কৌশল তাই: সব device বন্ধ রেখে CAN_H আর CAN_L-এর মাঝে resistance মাপুন। প্রায় 60 Ω মানে দুটি terminator আছে, প্রায় 120 Ω মানে একটি নেই, আর প্রায় 40 Ω মানে কেউ মাঝখানের কোনো node-এ তৃতীয় একটি বসিয়ে দিয়েছে (120 ∥ 120 ∥ 120 = 40 Ω)।
Bit rate আর তারের দৈর্ঘ্য পরস্পরের বিরুদ্ধে কাজ করে, কারণ arbitration (অংশ ৫): এক বিটের সময়ের মধ্যেই সবচেয়ে দূরের node-এর dominant বিট প্রেরকের কাছে ফিরে আসতে হবে। তারে সংকেত প্রতি মিটারে প্রায় 5 ns নেয় বলে প্রচলিত হিসাব, সঙ্গে transceiver আর controller-এর দেরি। তাই প্রচলিত নিয়মে 1 Mbit/s-এ bus প্রায় 40 m-এর মধ্যে, আর 125 kbit/s-এ কয়েক শ মিটার (প্রায় 500 m বলে প্রায়ই উল্লেখ করা হয়)। গুদামের তার এক শ মিটারের কাছাকাছি ধরলে 125 kbit/s নিরাপদ: এক বিট = 1 ÷ 125000 s = 8 µs.
নিরাপত্তা: আসল গাড়ির CAN bus-এ (যেমন OBD-II সংযোগ দিয়ে) পরীক্ষামূলক device জোড়া বা নিজে বানানো frame পাঠানো ব্রেক, steering বা airbag-এর ECU-র আচরণে প্রভাব ফেলতে পারে। শেখার জন্য টেবিলে নিজের বানানো bus ব্যবহার করুন, আর গাড়ির ১২/২৪ V সরবরাহ বা শিল্প-যন্ত্রের সরবরাহ নিয়ে কাজ শুধু অভিজ্ঞ কারও তত্ত্বাবধানে করুন।
৩ · CAN frame — ID, control, data, CRC আর ACK
Bosch CAN 2.0-তে চার ধরনের frame: data frame (data পাঠানো), remote frame (একটি ID-র data চেয়ে অনুরোধ, data অংশ নেই), error frame (ভুল ধরা পড়লে সবাইকে জানানো) আর overload frame (পরের frame-এর আগে বাড়তি সময় চাওয়া)। মূল কাজের frame হলো data frame; standard format-এ তার field-গুলো, তারে যাওয়ার ক্রমে:
| Field | বিট | মান ও কাজ |
|---|---|---|
| SOF (start of frame) | 1 | একটি dominant বিট; এর কিনারায় সব node নিজের ঘড়ি মেলায় |
| Identifier | 11 | ID10 থেকে ID0, MSB আগে; বিষয় আর অগ্রাধিকার |
| RTR | 1 | Data frame-এ dominant (0), remote frame-এ recessive (1) |
| IDE, r0 | 1 + 1 | IDE dominant = standard format; r0 সংরক্ষিত, dominant পাঠানো হয় |
| DLC | 4 | Data কত byte, 0–8 |
| Data | 0–64 | ০ থেকে ৮ byte, প্রতিটি byte MSB আগে |
| CRC sequence | 15 | CRC-15, SOF থেকে data পর্যন্ত (অংশ ৪) |
| CRC delimiter | 1 | Recessive |
| ACK slot + delimiter | 1 + 1 | প্রেরক দুটিই recessive পাঠায়; ঠিক CRC পাওয়া যেকোনো গ্রাহক slot-এ dominant দেয় |
| EOF (end of frame) | 7 | সাতটি recessive |
| Interframe space | 3 | পরের frame-এর আগে অন্তত তিনটি recessive (intermission) |
Standard data frame, n byte data: SOF থেকে EOF = 44 + 8n বিট; SOF থেকে CRC পর্যন্ত, যেখানে stuffing হয় = 34 + 8n বিট
Extended data frame: SOF, ID-A (১১), SRR, IDE, ID-B (১৮), RTR, r1, r0, DLC … = 64 + 8n বিট
Extended format (CAN 2.0B) ID-কে ২৯ বিটে বাড়ায়, যাতে বড় ব্যবস্থায় অনেক বার্তার জন্য ID-র অভাব না হয়। প্রথম ১১ বিট (ID-A)-এর পরে SRR আর IDE দুটোই recessive, তারপর বাকি ১৮ বিট (ID-B). একই ১১ বিটের base ID-র একটি standard আর একটি extended frame একসাথে শুরু করলে standard জেতে, কারণ RTR আর IDE-এর জায়গায় standard frame dominant পাঠায় আর extended frame recessive. একইভাবে একই ID-র data frame remote frame-এর কাছে হারে না, কারণ data frame-এর RTR dominant.
দুটি সূক্ষ্ম নিয়ম পরীক্ষায় আসে। প্রথমত, Bosch CAN 2.0-এর Part A বলে ID-র ওপরের সাতটি বিট (ID10–ID4) সব recessive হতে পারবে না; অর্থাৎ 0x7F0 থেকে 0x7FF পর্যন্ত ID নিষিদ্ধ। পরের মানগুলোতে এই নিয়ম নিয়ে বর্ণনা আলাদা পাওয়া যায়, তাই নতুন নকশায় এই পরিসর এড়িয়ে চলাই নিরাপদ। দ্বিতীয়ত, DLC-র চার বিটে 15 পর্যন্ত লেখা যায়, কিন্তু Bosch-এর spec data-র অনুমোদিত মান বলে কেবল 0 থেকে 8 byte (ISO-র পরের সংস্করণে classical frame-এ 9–15 কোডকে 8 byte ধরা হয় বলে বর্ণনা আছে; CAN FD-তে এদের নতুন অর্থ, অংশ ৭)।
ACK-এর অর্থ সাবধানে বুঝুন: ঠিক CRC পাওয়া যেকোনো একটি গ্রাহক dominant দিলেই প্রেরক dominant শোনে, তাই ACK মানে “অন্তত একজন ঠিক পেয়েছে”, “সবাই পেয়েছে” নয়। কোনো গ্রাহক ভুল পেলে সে নিজেই error frame দিয়ে সবাইকে জানায় (অংশ ৬)। আর bus-এ প্রেরক একা থাকলে কেউ ACK দেয় না: এর ফলও অংশ ৬-এ।
| Field | |
| বিট | |
| অর্থ | |
| মোট বিট (stuffing ছাড়া) | |
| Stuffing-এর পরে |
- SOF. Bus খালি (recessive) ছিল; T1 একটি dominant বিট দিয়ে শুরু করে। এর নেমে যাওয়া কিনারায় সব node নিজের বিট-ঘড়ি মিলিয়ে নেয় (hard synchronization).
- ID. 0x101 = 001 0000 0001, এগারো বিট, ID10 আগে। এই এগারো বিটেই arbitration হয় (অংশ ৫); এখানে T1-এর ঠিকানা নেই, আছে বার্তার বিষয়।
- RTR, IDE, r0. তিনটিই dominant: data frame (remote নয়), standard format (extended নয়), আর সংরক্ষিত বিট dominant পাঠানোর নিয়ম।
- DLC. 0010 = 2: পরের data অংশ দুই byte. গ্রাহক এখান থেকেই জানে CRC কখন শুরু হবে।
- Data. 0x04, 0x00: README-র TMP102-ধাঁচের মানে 0x0400 = 64 × 0.0625 °C = 4.00 °C. প্রতিটি byte MSB আগে।
- CRC. SOF থেকে data-র শেষ পর্যন্ত ৩৫ বিটের ওপর CRC-15 = 0x470A (নিচের Python আর board-এর run-এ মেলানো)। SOF থেকে CRC পর্যন্ত ৫০ বিটে stuffing হয়ে ৫৫ বিট।
- শেষ অংশ। CRC delimiter recessive; ACK slot-এ T1 recessive পাঠায়, কিন্তু COMP বা G ঠিক CRC পেলে dominant দেয়, তাই তারে 0; তারপর ACK delimiter আর সাতটি recessive EOF. মোট 65 বিট, পরের frame-এর আগে আরও তিনটি: 68 বিট = 125 kbit/s-এ 544 µs.
৪ · CRC-15 আর bit stuffing — ভুল ধরা আর ঘড়ি মেলানো
CRC (cyclic redundancy check)-এর তত্ত্ব, অর্থাৎ বিটের সারিকে polynomial ধরে mod-2 ভাগ, Computer Networks পর্ব ০৯-এ বিস্তারিত আছে। CAN-এর নির্দিষ্ট রূপ Bosch CAN 2.0-এর Part A, পৃষ্ঠা ১৩–১৪-এ: generator polynomial x15 + x14 + x10 + x8 + x7 + x4 + x3 + 1 (hex-এ 0x4599), ভাগ করা হয় SOF, arbitration, control আর data field-এর destuffed বিটের সারি, শুরুর মান 0. Spec নিজেই একটি ১৫ বিটের shift register-এর pseudocode দেয়: প্রতিটি নতুন বিট register-এর সবচেয়ে উঁচু বিটের সঙ্গে XOR, register এক ঘর বাঁয়ে, আর XOR-এর ফল 1 হলে register-এ 0x4599 XOR. CAN in Automation (CiA)-র বর্ণনায় এই CRC-র Hamming distance ৬, অর্থাৎ একটি frame-এ এলোমেলো পাঁচটি পর্যন্ত বিট-ভুল নিশ্চিতভাবে ধরা পড়ে।
দ্বিতীয় যন্ত্র bit stuffing. CAN-এর তারে NRZ coding (ছবি ৫২.২): একই বিট পরপর এলে তারে কোনো কিনারা নেই। প্রতিটি node-এর নিজের oscillator, আর লম্বা সময় কিনারা না পেলে গ্রাহকের ঘড়ি সরে যায়। নিয়মটি তাই সরল (Bosch CAN 2.0, অংশ ৫ “Coding”): প্রেরক পাঠানোর সারিতে পাঁচটি একই বিট দেখলেই পরে একটি উল্টো বিট বসায়। এতে প্রতি সর্বোচ্চ পাঁচ বিটে একটি কিনারা নিশ্চিত হয়। গ্রাহক একই নিয়মে বসানো বিটটি মুছে ফেলে। Stuffing হয় SOF থেকে CRC sequence পর্যন্ত; CRC delimiter, ACK আর EOF-এর নির্দিষ্ট রূপ, তাদের stuffing নেই।
Stuffing-এর একটি দ্বিতীয় সুবিধা আছে: ছয়টি একই বিট এখন stuffing-যুক্ত অংশে “অসম্ভব”। তাই ছয়টি dominant বিট (active error flag, অংশ ৬) সবাই সঙ্গে সঙ্গে ভুল হিসেবে চেনে। আর সাতটি recessive-এর EOF stuffing-এর নিয়মের বাইরে বলে frame-এর শেষ চেনা যায়। HDLC-ও bit stuffing করে, কিন্তু শুধু পাঁচটি 1-এর পরে, flag 01111110 লুকাতে (Computer Networks পর্ব ১০); CAN 0 আর 1 দুটোর পরেই করে, কারণ উদ্দেশ্য ঘড়ি মেলানো।
১. পাঁচটি একই বিটের পরে একটি উল্টো বিট; SOF থেকে CRC sequence পর্যন্ত
২. বসানো stuff বিটও পরের গোনায় ধরা হয়: 00000[1]1111[0]…
৩. গ্রাহক stuffing-যুক্ত অংশে ছয়টি একই বিট দেখলে: stuff error
৪. CRC হিসাব হয় stuff বিট বাদ দিয়ে (classical CAN-এ)
নিচের ব্লক এই দুই নিয়ম Bosch-এর বর্ণনা মেনে লেখে, একটি পরিচিত test vector দিয়ে CRC যাচাই করে, তারপর T1-এর frame বানায়। পরের দুটি ব্লক এই function ব্যবহার করে, তাই তিনটি একই namespace-এ চলে। ব্লকটি আমার lab-এর can_model.py-এর সংক্ষিপ্ত রূপ:
# Classical CAN data frame: CRC-15 (Bosch CAN 2.0) আর bit stuffing
def bits(v, n): return [(v >> (n - 1 - i)) & 1 for i in range(n)]
def crc15(bs):
reg = 0
for b in bs:
nxt = b ^ (reg >> 14)
reg = (reg << 1) & 0x7FFF
if nxt: reg ^= 0x4599 # x^15+x^14+x^10+x^8+x^7+x^4+x^3+1
return reg
def stuff(bs): # ৫টি একই বিটের পরে উল্টো বিট
out, run, last, where = [], 0, None, []
for b in bs:
out.append(b)
run = run + 1 if b == last else 1
last = b
if run == 5:
out.append(1 - b); where.append(len(out) - 1)
last, run = 1 - b, 1 # stuff বিটও পরের গোনায়
return out, where
def frame(ident, data): # standard format, data frame
raw = [0] + bits(ident, 11) + [0, 0, 0] + bits(len(data), 4)
raw += [b for byte in data for b in bits(byte, 8)]
crc = crc15(raw)
wire, where = stuff(raw + bits(crc, 15))
return raw, crc, wire, where
print("CRC-15 check, '123456789':", hex(crc15([b for c in b"123456789" for b in bits(c, 8)])))
print("ID 0x014, data 01 → CRC =", f"{frame(0x014, [0x01])[1]:015b}")
raw, crc, wire, where = frame(0x101, [0x04, 0x00]) # T1: 4.00 °C = 0x0400
print("ID 0x101, DLC 2, data 04 00 → CRC =", f"0x{crc:04X} = {crc:015b}")
print("stuffing-এর আগে", len(raw) + 15, "বিট, পরে", len(wire), "বিট; stuff বিট:", where)
print("".join(f"[{b}]" if i in where else str(b) for i, b in enumerate(wire)))
print("পুরো frame (CRC delim, ACK, EOF সহ):", len(wire) + 10, "বিট, IFS-সহ", len(wire) + 13)আসল আউটপুট (ব্রাউজারের Python):
CRC-15 check, '123456789': 0x59e
ID 0x014, data 01 → CRC = 111011101010011
ID 0x101, DLC 2, data 04 00 → CRC = 0x470A = 100011100001010
stuffing-এর আগে 50 বিট, পরে 55 বিট; stuff বিট: [9, 18, 25, 33, 39]
000100000[1]00100000[1]100000[1]0100000[1]00000[1]100011100001010
পুরো frame (CRC delim, ACK, EOF সহ): 65 বিট, IFS-সহ 68
প্রথম লাইন একটি স্বাধীন যাচাই: CRC-এর পরিচিত তালিকা (Greg Cook-এর “CRC RevEng” catalogue) CRC-15/CAN-এর জন্য ASCII “123456789”-এর check মান লেখে 0x059E, আর আমাদের function ঠিক তাই দিয়েছে। দ্বিতীয় লাইন আরেকটি: Wikimedia Commons-এ CAN bus-এর একটি পরিচিত ছবিতে (ID 0x014, DLC 1, data 0x01) ছবির CRC ভুল বলে টীকা আছে, আর টীকায় সঠিক মান লেখা 111011101010011; আমাদের ফলও তাই। তারপর T1-এর frame: CRC 0x470A, আর stuff বিট পাঁচটি, সবগুলো 1, কারণ এই frame-এ লম্বা সারি সবই 0-এর। বন্ধনীর বিটগুলো তারে যায়, কিন্তু CRC-র হিসাবে নেই। ৫৫ + ১০ = ৬৫ বিট frame, আর পরের frame-এর আগে তিনটি intermission বিট মিলে ৬৮.
| Stuff বিটের জায়গা | |
| আগের পাঁচ বিট | |
| কোন field থেকে | |
| বসানো বিট | |
| পরের বিট |
- ID-র ভেতরে। SOF 0, তারপর 001, তারপর ID7–ID3 পাঁচটি 0. পঞ্চম 0-এর পরে (index 8) প্রেরক একটি 1 বসায়, index 9-এ। ID2 আসে তার পরে।
- Field পেরিয়ে। ID0 = 1-এর পরে RTR, IDE, r0 তিনটিই 0, আর DLC-র প্রথম দুই বিট 00: পাঁচটি 0 দুটি আলাদা field থেকে। Stuffing field দেখে না, শুধু তারের সারি দেখে: index 18-এ 1.
- DLC থেকে data-য়। Stuff 1-এর পরে DLC1 = 1 (দুটি 1 পাশাপাশি, সমস্যা নেই), তারপর DLC0 = 0 আর data 0x04-এর ওপরের চার বিট 0000: আবার পাঁচটি 0, index 25-এ 1.
- দুই byte জুড়ে। 0x04-এর 1 বিটের পরে byte ১-এর শেষ দুটি 0 আর byte ২-এর প্রথম তিনটি 0: index 33-এ 1. Stuff বিট byte-এর সীমানাও মানে না।
- CRC-র ঠিক আগে। Byte ২-এর বাকি পাঁচটি 0-এর পরে index 39-এ 1; তারপর CRC 1000111… শুরু। CRC-র নিজের বিটগুলোতে আর পাঁচটি একই বিট নেই, তাই সেখানে stuff নেই।
- ফল। ৫০ বিট থেকে ৫৫. গ্রাহক প্রতিটি পাঁচ-সারির পরের বিট মুছে আবার ৫০ বিট পায়, আর তার ওপর CRC হিসাব করে 0x470A মেলায়। সবচেয়ে খারাপ ক্ষেত্রে stuff বিট অনেক বেশি হতে পারে (অংশ ৫-এর হিসাব)।
Board-এ সত্যিকারের cross-check — একই কাজ C-তে
Python মডেল ঠিক কি না, তার আরেকটি পরীক্ষা: একই CRC আর stuffing-এর কোড C-তে আলাদা করে লিখে (আমার lab-এর fw/can_crc.c) কোর্সের reference lab-এর build দিয়ে Clang-এ compile করে virtual board-এ চালানো। Firmware দুটি frame বানিয়ে UART-এ ছাপে। মূল অংশ:
static uint16_t crc15(const uint8_t *b, uint32_t n) /* Bosch CAN 2.0 */
{
uint16_t reg = 0;
for (uint32_t i = 0; i < n; i++) {
uint32_t nxt = b[i] ^ ((reg >> 14) & 1u);
reg = (uint16_t)((reg << 1) & 0x7FFFu);
if (nxt) reg ^= 0x4599u;
}
return reg;
}
/* stuff(): run == 5 হলে উল্টো বিট বসানো, last = !last, run = 1 */সত্যিকারের run — board.py run build/can_crc.elf (BG-M3, Clang 22.1.8 -O2)
[ 0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[ 0.1921 ms] UART: id=0x101 crc=0x470A bits=50 stuffed=55 (+5)
[ 0.2835 ms] UART: 0001000001001000001100000101000001000001100011100001010
[ 0.4274 ms] UART: id=0x014 crc=0x7753 bits=42 stuffed=45 (+3)
[ 0.5025 ms] UART: 000001001010000010001000001001111011101010011
[ 0.5031 ms] exit(0) after 4025 cycles
দুই frame-এই CRC আর তারের ৫৫ ও ৪৫ বিটের পুরো সারি Python-এর সঙ্গে হুবহু মিলেছে; 0x7753 = 111011101010011, Commons-এর টীকার মান। সময়গুলো board-এর নিজস্ব (প্রতি নির্দেশ এক cycle, Spec decision 17). আসল MCU-তে এই কাজ CAN controller-এর hardware করে; এমন কোড কাজে লাগে test-এ আর logic analyzer-এর ধারণ করা বিট বিশ্লেষণে। Toolchain: ziglang 0.17.1 (MIT) থেকে Clang 22.1.8 (LLVM, Apache-2.0 with LLVM exception), board চলে unicorn 2.1.4-এ (binding BSD, engine GPLv2).
৫ · Arbitration — ID যত ছোট, অগ্রাধিকার তত বেশি
অনেক node-এর একটি তার থাকলে প্রশ্ন আসে: দুজন একসাথে পাঠাতে চাইলে কী হবে? ক্লাসিক Ethernet-এর উত্তর ছিল CSMA/CD: সংঘর্ষ ধরা পড়লে দুজনই থামে, কিছুক্ষণ এলোমেলো অপেক্ষা করে আবার চেষ্টা করে (Computer Networks পর্ব ১১)। এতে সংঘর্ষের সময় নষ্ট হয়, আর অপেক্ষা এলোমেলো, তাই সবচেয়ে খারাপ দেরির নিশ্চয়তা নেই। CAN-এর উত্তর bitwise arbitration, যাকে কখনো CSMA/CR (collision resolution) বলা হয়:
- Bus খালি থাকলে পাঠাতে ইচ্ছুক সব node একসাথে SOF দেয় আর ID পাঠাতে থাকে।
- প্রতিটি বিট পাঠিয়ে প্রতিটি node তার শোনে। তারের মান = সবার বিটের AND (অংশ ২)।
- যে node recessive (1) পাঠিয়ে dominant (0) শোনে, সে বোঝে আরও জরুরি কেউ পাঠাচ্ছে। সে সঙ্গে সঙ্গে পাঠানো থামিয়ে গ্রাহক হয়ে যায়; Bosch spec অনুযায়ী arbitration field-এ এটি bit error নয়।
- ID-র শেষে একজনই বাকি থাকে: সবচেয়ে ছোট ID. তার frame-এর একটি বিটও নষ্ট হয়নি, কারণ জয়ীর প্রতিটি বিটই তারে ছিল। হেরেরা bus আবার খালি হলে চেষ্টা করে।
একটি শর্ত অপরিহার্য: দুটি node কখনো একই ID-তে data পাঠাবে না। একই ID হলে দুজনই arbitration “জেতে”, আর data-র প্রথম অমিল বিটে একজন bit error পায়: frame নষ্ট। তাই ID-র তালিকা নকশার কাজ, প্রতিটি node-এর একটি নিজস্ব ID-পরিসর। নিচের ব্লক আগের frame() দিয়ে তিন node-এর আসল বিট নিয়ে তারের AND চালায়:
# Bitwise arbitration: তার wired-AND, 0 (dominant) সবসময় জেতে
def arbitrate(nodes, show=False):
wires = {n: frame(i, d)[2] for n, (i, d) in nodes.items()}
active, k = set(nodes), 0
while len(active) > 1:
sent = {n: wires[n][k] for n in sorted(active)}
bus = min(sent.values()) # কেউ 0 দিলেই তারে 0
lost = [n for n in sent if sent[n] == 1 and bus == 0]
if show:
print(f"bit {k:2}: " + " ".join(f"{n}={b}" for n, b in sent.items())
+ f" → তারে {bus}" + (f" ✗ হারল: {', '.join(lost)}" if lost else ""))
active -= set(lost)
k += 1
return active.pop()
nodes = {"T1": (0x101, [0x04, 0x00]), "T2": (0x102, [0x08, 0x40]),
"COMP": (0x200, [0x01])}
print("জয়ী:", arbitrate(nodes, show=True))
order, waiting = [], dict(nodes)
while waiting: # হারা node পরের সুযোগে আবার চেষ্টা করে
w = arbitrate(waiting) if len(waiting) > 1 else next(iter(waiting))
order.append(f"{w}(0x{waiting.pop(w)[0]:03X})")
print("তারে পাঠানোর ক্রম:", " → ".join(order))আসল আউটপুট (ব্রাউজারের Python):
bit 0: COMP=0 T1=0 T2=0 → তারে 0
bit 1: COMP=0 T1=0 T2=0 → তারে 0
bit 2: COMP=1 T1=0 T2=0 → তারে 0 ✗ হারল: COMP
bit 3: T1=1 T2=1 → তারে 1
bit 4: T1=0 T2=0 → তারে 0
bit 5: T1=0 T2=0 → তারে 0
bit 6: T1=0 T2=0 → তারে 0
bit 7: T1=0 T2=0 → তারে 0
bit 8: T1=0 T2=0 → তারে 0
bit 9: T1=1 T2=1 → তারে 1
bit 10: T1=0 T2=0 → তারে 0
bit 11: T1=0 T2=1 → তারে 0 ✗ হারল: T2
জয়ী: T1
তারে পাঠানোর ক্রম: T1(0x101) → T2(0x102) → COMP(0x200)
বিট ২ হলো ID9: 0x200-এর ID9 = 1, বাকিদের 0, তাই COMP প্রথমেই সরে যায়। T1 আর T2-এর ID প্রথম নয়টি বিটে এক, তাই stuffing-ও এক (বিট 9-এ দুজনেরই stuff 1). পার্থক্য ID1-এ, বিট 11-এ। Index-গুলো তারের আসল বিটের, stuff বিটসহ।
ছবি ৫২.৩ — তিন node-এর arbitration, তারের বিট 0 থেকে 11
ওপরে ID বিটের নাম; ✗ = সেই বিটে হার, তারপর ডটেড দাগ = শুধু শোনা
| বিট | |
| T1 (0x101) | |
| T2 (0x102) | |
| COMP (0x200) | |
| তারে |
- একসাথে শুরু। তিনজনই bus খালি দেখে SOF দেয়, আর ID10-ও তিনজনের 0. তারে 0, কেউ কোনো অমিল দেখে না।
- COMP হারে। ID9-এ COMP 1 পাঠায়, T1 আর T2 পাঠায় 0. তার 0, COMP নিজের 1 শুনতে পায়নি: সে থেমে গ্রাহক হয়। কোনো ভুল বার্তা নেই, কোনো সময় নষ্ট নেই।
- দুজন সমান। ID8–ID3-এ T1 আর T2-এর বিট এক, 100000. তারে তাদের যৌথ মান। এই ছয় বিট কেউ জানে না যে আরেকজনও পাঠাচ্ছে।
- Stuff বিট। ID7–ID3-এর পাঁচটি 0-এর পরে দুজনেই একই stuff 1 বসায়, কারণ এ পর্যন্ত দুজনের সারি এক। ভিন্ন ID-র node-দের stuff বিট সবসময় তাদের প্রথম অমিলের পরেই আলাদা হতে পারে।
- T2 হারে। ID2 দুজনের 0; ID1-এ T1 0, T2 1. তার 0, T2 সরে যায়। T1 বাকি RTR, control, data, CRC পাঠায়, আর সেটিই সবাই শোনে।
- পরের পালা। T1-এর frame আর intermission-এর পরে T2 আর COMP আবার শুরু করে; 0x102 < 0x200, তাই T2, তারপর COMP. মোট ক্রম ID-র ছোট থেকে বড়।
সময়ের হিসাব — frame-এর দৈর্ঘ্য, bus load আর সবচেয়ে খারাপ অপেক্ষা
Arbitration-এর বড় লাভ পূর্বানুমেয়তা: সবচেয়ে জরুরি বার্তা কত দেরিতে পৌঁছাবে, তা হিসাব করা যায়। একটি frame একবার শুরু হলে কেউ তা থামায় না (non-preemptive), তাই সবচেয়ে জরুরি বার্তাকেও সবচেয়ে খারাপ ক্ষেত্রে চলতি একটি লম্বা frame শেষ হওয়া পর্যন্ত অপেক্ষা করতে হতে পারে। সবচেয়ে লম্বা frame-এর জন্য stuff বিটের সর্বোচ্চ সংখ্যা লাগে: stuff বিট নিজেও পরের সারিতে গোনা হয় বলে 00000[1]1111[0]0000[1]…-এর মতো সারিতে প্রথম পাঁচের পরে প্রতি চার বিটে একটি stuff আসতে পারে, তাই stuffing-যুক্ত g বিটে সর্বোচ্চ ⌊(g − 1) ÷ 4⌋টি। এই সূত্র CAN-এর real-time বিশ্লেষণের সাহিত্যে (যেমন Davis ও সহকর্মীদের ২০০৭ সালের CAN schedulability-এর পুনর্বিবেচনা) প্রচলিত। নিচের ব্লক বাজারঘরের গুদামের বার্তাগুলোর আসল বিট গুনে bus load হিসাব করে:
# বাজারঘরের cold-storage bus: frame-এর সময় আর bus load, 125 kbit/s-এ
BITRATE = 125_000
bit_us = 1e6 / BITRATE
msgs = [("T1 তাপমাত্রা", 0x101, [0x04, 0x00], 1.0), # (নাম, ID, data, প্রতি কত s-এ)
("T2 তাপমাত্রা", 0x102, [0x08, 0x40], 1.0),
("T3 তাপমাত্রা", 0x103, [0x05, 0x80], 1.0),
("Compressor অবস্থা", 0x200, [0x01], 1.0)]
total = 0.0
for name, ident, data, period in msgs:
wire = frame(ident, data)[2]
nbits = len(wire) + 10 + 3 # + CRC delim, ACK ২, EOF ৭, IFS ৩
total += nbits / period
print(f"0x{ident:03X} {name}: {len(data)} byte, {nbits} বিট = {nbits * bit_us:.0f} µs")
print(f"প্রতি সেকেন্ডে {total:.0f} বিট → bus load {100 * total / BITRATE:.3f}%")
for n in (0, 8): # সবচেয়ে খারাপ stuffing
base = 8 * n + 44 # SOF থেকে EOF, stuffing ছাড়া
worst = (34 + 8 * n - 1) // 4 # SOF..CRC অংশে সর্বোচ্চ stuff বিট
longest = base + worst + 3
print(f"{n} byte: {base} বিট + সর্বোচ্চ {worst} stuff = {base + worst} বিট"
f" (+IFS {longest} = {longest * bit_us:.0f} µs)")
alarm = len(frame(0x051, [0x01])[2]) + 13 # সবচেয়ে জরুরি বার্তা
print(f"0x051 alarm: {alarm} বিট; সবচেয়ে খারাপ অপেক্ষা ≈ {longest} + {alarm} বিট"
f" = {(longest + alarm) * bit_us:.0f} µs")
p = [0] * 5 + [1, 1, 1, 1, 0, 0, 0, 0] * 3 # এমন সারিতে প্রতি ৪ বিটে একটি stuff
w, where = stuff(p)
print(f"{len(p)} বিটের সারি → {len(w)} বিট, stuff {len(where)}টি:",
"".join(f"[{b}]" if i in where else str(b) for i, b in enumerate(w)))আসল আউটপুট (ব্রাউজারের Python):
0x101 T1 তাপমাত্রা: 2 byte, 68 বিট = 544 µs
0x102 T2 তাপমাত্রা: 2 byte, 68 বিট = 544 µs
0x103 T3 তাপমাত্রা: 2 byte, 68 বিট = 544 µs
0x200 Compressor অবস্থা: 1 byte, 60 বিট = 480 µs
প্রতি সেকেন্ডে 264 বিট → bus load 0.211%
0 byte: 44 বিট + সর্বোচ্চ 8 stuff = 52 বিট (+IFS 55 = 440 µs)
8 byte: 108 বিট + সর্বোচ্চ 24 stuff = 132 বিট (+IFS 135 = 1080 µs)
0x051 alarm: 58 বিট; সবচেয়ে খারাপ অপেক্ষা ≈ 135 + 58 বিট = 1544 µs
29 বিটের সারি → 36 বিট, stuff 7টি: 00000[1]1111[0]0000[1]1111[0]0000[1]1111[0]0000[1]
গুদামের bus প্রায় খালি: প্রতি সেকেন্ডে ২৬৪ বিট, 125 kbit/s-এর মাত্র ০.২১১%. আট byte-এর frame-এ সবচেয়ে খারাপ ক্ষেত্রে ২৪টি stuff বিট, মোট ১৩২ বিট, intermission-সহ ১৩৫ বিট = 1080 µs; শেষ লাইনের সারি দেখায় কীভাবে প্রতি চার বিটে একটি stuff আসে। তাই T1-এর alarm (0x051) যত দেরিতেই আসুক, ভুল না ঘটলে প্রায় 1.5 ms-এর মধ্যে পৌঁছায়: একটি লম্বা frame শেষের অপেক্ষা আর নিজের ৫৮ বিট। হিসাবটি ধরে নেয় node-এর ভেতরেও controller সবচেয়ে জরুরি বার্তা আগে পাঠায়; FIFO-ধাঁচের পাঠানোর buffer-এ কম জরুরি বার্তা সামনে আটকে থাকলে তা ভাঙে, পর্ব ৫৭-এর priority inversion-এর মতো।
আরেকটি প্রচলিত পরীক্ষার হিসাব: “efficiency”. আট byte, অর্থাৎ ৬৪ বিট data পাঠাতে stuffing ছাড়া ১০৮ + ৩ = ১১১ বিট, সবচেয়ে খারাপ ক্ষেত্রে ১৩৫ বিট। কার্যকর হার তাই ৬৪ ÷ ১১১ ≈ ৫৭.৭% থেকে ৬৪ ÷ ১৩৫ ≈ ৪৭.৪%. 1 Mbit/s-এর CAN-এ data আসলে আধা Mbit/s-এর কাছাকাছি: CAN FD-এর জন্মের একটি কারণ এটি (অংশ ৭)।
৬ · ভুল ধরা আর সামলানো — error frame, TEC/REC আর bus-off
গাড়ি বা কারখানার তারে noise অনিবার্য, তাই CAN-এর নকশার বড় অংশ ভুল নিয়ে। Bosch CAN 2.0 (Part A, অংশ ৬.১) পাঁচ ধরনের ভুল সংজ্ঞায়িত করে, যেগুলো একসাথেও ঘটতে পারে:
| ভুল | কে ধরে | কখন |
|---|---|---|
| Bit error | প্রেরক | পাঠানো বিট আর তারে শোনা বিট আলাদা; ব্যতিক্রম arbitration field আর ACK slot-এ recessive পাঠিয়ে dominant শোনা |
| Stuff error | সবাই | Stuffing-যুক্ত অংশে ষষ্ঠ একই বিট |
| CRC error | গ্রাহক | নিজের হিসাবের CRC আর পাওয়া CRC আলাদা |
| Form error | সবাই | নির্দিষ্ট রূপের field-এ (CRC delimiter, ACK delimiter, EOF) ভুল বিট |
| ACK error | প্রেরক | ACK slot-এ কোনো dominant নেই |
ভুল ধরা node একটি error flag পাঠায়: “error active” অবস্থায় ছয়টি dominant বিট (active error flag). Stuffing-যুক্ত অংশে এটি নিজেই stuff error, আর নির্দিষ্ট রূপের অংশে form error, তাই বাকি সব node-ও ভুল দেখে নিজেদের flag পাঠায়। ফলে তারে dominant-এর সারি ৬ থেকে ১২ বিট লম্বা হয়, তারপর আটটি recessive-এর error delimiter. প্রেরক তারপর নিজে থেকেই frame আবার পাঠায়; firmware-কে কিছু করতে হয় না। ফলে একটি গ্রাহকও ভুল পেলে frame সবার জন্য বাতিল হয়।
নিচের stepper-এর প্রতিটি index আমার lab-এর একটি বিট-স্তরের simulation (errsim.py) থেকে নেওয়া: T1-এর frame-এ data 0x04-এর একমাত্র 1 বিট পাঠানোর মুহূর্তে (তারের index 27) একটি ক্ষণিকের spike তারকে dominant করে দেয়।
| Index | |
| তারে | |
| T1 (প্রেরক) | |
| COMP, T2, T3, G | |
| অবস্থা |
- Spike. Index 26-এ T1 নিয়মমতো 0 পাঠায়; 27-এ 0x04-এর 1 পাঠায়, কিন্তু spike তারকে 0 রাখে। T1 নিজের পাঠানো বিট শুনতে না পেয়ে bit error ধরে। এটি arbitration field নয়, তাই ব্যতিক্রম খাটে না।
- T1-এর flag. পরের বিট (28) থেকে T1 ছয়টি dominant পাঠায়, 28–33. গ্রাহকেরা 26–30-এ পাঁচটি 0 দেখেছে, 31-এ নিয়মমতো একটি stuff 1 আশা করে, কিন্তু পায় 0: stuff error.
- সবার flag. গ্রাহকেরা 32 থেকে নিজেদের ছয়টি dominant দেয়, 32–37. দুই দল flag-এর মিলিত ফল 28–37, আর spike-সহ 26 থেকে 37 পর্যন্ত বারোটি 0. T1 নিজের flag শেষে চারটি বাড়তি dominant দেখে; spec সাতটি পর্যন্ত বাড়তি dominant সহ্য করে (নিয়ম ৬)।
- বিরতি। 38–45-এ আটটি recessive (error delimiter), 46–48-এ তিনটি intermission. সবাই আবার এক জায়গায়।
- Counter. Bosch-এর নিয়ম ৩: প্রেরক error flag পাঠালে TEC +8, তাই T1-এর TEC 8. নিয়ম ১: গ্রাহক ভুল ধরলে REC +1. কেউ flag-এর পরের প্রথম বিটে dominant দেখেনি, তাই নিয়ম ২-এর +8 কারও লাগেনি।
- আবার পাঠানো। Index 49-এ T1 আবার SOF দেয় (অন্য কেউ চাইলে আবার arbitration). এবার সফল: নিয়ম ৭-এ TEC −1 = 7, নিয়ম ৮-এ প্রতিটি গ্রাহকের REC −1 = 0. এক spike-এর দাম: কয়েক শ µs আর T1-এর খাতায় ৭ পয়েন্ট।
TEC, REC আর তিন অবস্থা
একটি node-এর নিজের hardware খারাপ হলে (ভাঙা transceiver, ভুল bit rate) সে প্রতিটি frame-এ error flag দিয়ে পুরো bus অচল করে দিতে পারে। এই ঝুঁকি সামলাতে প্রতিটি node দুটি error counter রাখে, TEC (transmit error count) আর REC (receive error count), আর Bosch CAN 2.0-এর অংশ ৭-এর ১২টি নিয়ম মেনে চলে। মূল কথাগুলো:
পাঠানোয় ভুল: TEC +8 · গ্রাহক হিসেবে ভুল: REC +1 (কিছু ক্ষেত্রে +8) · সফল পাঠানো: TEC −1 · সফল পাওয়া: REC −1
Error-active: দুটিই ≤ 127 · Error-passive: যেকোনোটি ≥ 128 · Bus-off: TEC ≥ 256
Bus-off থেকে ফেরা: 128 বার 11টি পরপর recessive বিট দেখার পরে, দুই counter শূন্যে
Error-passive node এখনো যোগাযোগ করে, কিন্তু ভুল দেখলে শুধু ছয়টি recessive বিটের passive error flag দিতে পারে, যা অন্যদের frame নষ্ট করে না, আর নিজে পাঠানোর পরে আরও আটটি বিট অপেক্ষা করে (suspend transmission). Bus-off node তারে কোনো প্রভাবই রাখতে পারে না, যেন তার driver বন্ধ। +8 আর −1-এর অসমতাই আসল কৌশল: মাঝে মাঝে ভুল হলে counter শূন্যের দিকে ফেরে, কিন্তু প্রায় প্রতি আটটি frame-এ একটির বেশি ভুল হলে উঠতেই থাকে। নিচের ব্লক কয়েকটি নিয়ম মডেল করে:
# CAN-এর fault confinement: TEC/REC-এর কয়েকটি নিয়ম (Bosch CAN 2.0, Part A §7)
class Node:
def __init__(s, name): s.name, s.tec, s.rec, s.off = name, 0, 0, False
def state(s):
if s.off: return "bus-off"
return "error-passive" if s.tec >= 128 or s.rec >= 128 else "error-active"
def tx_error(s, ack_error=False):
if ack_error and s.state() == "error-passive":
return # ব্যতিক্রম ১: TEC বদলায় না
s.tec += 8 # নিয়ম ৩
if s.tec >= 256: s.off = True # নিয়ম ১০
def tx_ok(s): s.tec = max(0, s.tec - 1) # নিয়ম ৭
def rx_error(s): s.rec += 1 # নিয়ম ১
def rx_ok(s): # নিয়ম ৮ (127-এর বেশি হলে 119–127-এর একটি মান)
s.rec = s.rec - 1 if 1 <= s.rec <= 127 else (0 if s.rec == 0 else 120)
def show(s): return f"{s.name}: TEC={s.tec} REC={s.rec} {s.state()}"
t1, r = Node("T1"), Node("COMP")
t1.tx_error(); r.rx_error() # তারে একটি spike: frame নষ্ট
print("spike-এর পরে: ", t1.show(), "|", r.show())
t1.tx_ok(); r.rx_ok() # আবার পাঠানো, এবার ঠিক
print("আবার পাঠানোর পরে:", t1.show(), "|", r.show())
t3 = Node("T3") # transceiver-এর তার ছেঁড়া: প্রতিবার bit error
for n in range(1, 33):
t3.tx_error()
if n in (12, 16, 31, 32): print(f"{n:2}টি ব্যর্থ চেষ্টা →", t3.show())
alone = Node("একা") # bus-এ আর কেউ নেই: ACK আসে না
for n in range(1, 41): alone.tx_error(ack_error=True)
print("একা node, ৪০টি ACK error →", alone.show())
for kbps in (125, 500): # bus-off থেকে ফেরার সর্বনিম্ন সময়
print(f"{kbps} kbit/s-এ 128 × 11 recessive বিট = {128 * 11 / kbps:.3f} ms")আসল আউটপুট (ব্রাউজারের Python):
spike-এর পরে: T1: TEC=8 REC=0 error-active | COMP: TEC=0 REC=1 error-active
আবার পাঠানোর পরে: T1: TEC=7 REC=0 error-active | COMP: TEC=0 REC=0 error-active
12টি ব্যর্থ চেষ্টা → T3: TEC=96 REC=0 error-active
16টি ব্যর্থ চেষ্টা → T3: TEC=128 REC=0 error-passive
31টি ব্যর্থ চেষ্টা → T3: TEC=248 REC=0 error-passive
32টি ব্যর্থ চেষ্টা → T3: TEC=256 REC=0 bus-off
একা node, ৪০টি ACK error → একা: TEC=128 REC=0 error-passive
125 kbit/s-এ 128 × 11 recessive বিট = 11.264 ms
500 kbit/s-এ 128 × 11 recessive বিট = 2.816 ms
প্রথম দুই লাইন stepper-এর counter: 8 আর 1, তারপর 7 আর 0. ভাঙা transceiver-এর T3 ১২টি ব্যর্থ চেষ্টায় TEC 96-এ (spec-এর টীকা বলে প্রায় 96-এর বেশি মানে খুব বিরক্ত bus, আর অনেক controller এখানে একটি “warning” flag দেয়), ১৬টিতে 128-এ error-passive, আর ৩২টিতে 256-এ bus-off: নিজেকে bus থেকে সরিয়ে নিল, বাকি চারটি node স্বাভাবিক চলবে। তৃতীয় ঘটনাটি পরীক্ষার প্রিয়: bus-এ একা একটি node (ধরুন গুদামে প্রথম চালু হওয়া T1) ACK পায় না। প্রতিবার TEC +8, কিন্তু error-passive হওয়ার পরে ব্যতিক্রম ১ অনুযায়ী ACK error-এ TEC আর বাড়ে না: সে 128-এ থেমে থাকে, bus-off হয় না, আর অন্য node চালু হলেই তার বার্তা পৌঁছায়। Bosch-এর spec এই ক্ষেত্রটি আলাদা টীকায় লিখেছে। শেষ দুই লাইন bus-off থেকে ফেরার সর্বনিম্ন সময়।
Bus-off-এর পরে কী হবে, তা firmware-এর নীতি। STM32F1-এর bxCAN-এ নিজে থেকে ফেরার জন্য একটি automatic bus-off management (ABOM) বিট আছে বলে RM0008-এর বর্ণনা; বন্ধ থাকলে software ফেরার অনুরোধ করে। ভালো নীতি: অপেক্ষার পরে ফেরা, আর বারবার bus-off হলে লগ রাখা (নির্ভরযোগ্যতার বড় ছবি পর্ব ৬৩-এ)।
৭ · আসল chip, bit timing, CAN FD আর ওপরের স্তর
বাস্তবে frame, CRC, stuffing, arbitration আর error counter সব করে MCU-র ভেতরের CAN controller; firmware শুধু বার্তা লেখে আর পড়ে। STM32F1 পরিবারের reference manual RM0008-এর bxCAN অধ্যায় অনুযায়ী (আপনার revision মিলিয়ে নিন): CAN 2.0A আর 2.0B দুটোই, 1 Mbit/s পর্যন্ত, পাঠানোর জন্য তিনটি transmit mailbox, পাওয়ার জন্য দুটি receive FIFO (প্রতিটিতে তিনটি বার্তা), আর ID বাছাইয়ের জন্য connectivity line ছাড়া অন্য STM32F10x-এ ১৪টি filter bank. একটি পরিচিত ফাঁদ: STM32F103-এ USB আর CAN একটি 512 byte-এর SRAM ভাগ করে, তাই দুটি একসাথে ব্যবহার করা যায় না। আর MCU-র CAN pin সরাসরি bus-এ নয়: মাঝে একটি আলাদা CAN transceiver chip লাগে।
Filter-এর কাজটি বোঝা দরকার, কারণ এটি CPU বাঁচায়। প্রতিটি filter একটি acceptance filter: “ID-র যে বিটগুলো mask-এ 1, সেগুলো filter-এর মানের সঙ্গে মিললে বার্তাটি রাখা হবে”। Gateway সব রাখে; COMP শুধু তাপমাত্রা আর alarm চায়। অনুশীলন ১-এ এমন একটি filter নকশা করবেন।
Bit timing আর sample point
CAN controller এক বিটের সময়কে কয়েকটি ছোট এককে ভাগ করে, যার নাম time quantum (tq). এক বিট = sync segment (1 tq, যেখানে কিনারা আশা করা হয়) + propagation আর phase segment 1 + phase segment 2. বিটের মান পড়া হয় phase segment 1-এর শেষে, এই মুহূর্তের নাম sample point; গ্রাহক প্রতিটি recessive থেকে dominant কিনারায় এই ভাগগুলো একটু লম্বা বা ছোট করে নিজের ঘড়ি মেলায় (resynchronization). অনেক ব্যবস্থায় sample point বিটের প্রায় 87.5%-এ রাখা হয়, যা CiA-র সুপারিশ হিসেবে প্রায়ই উল্লেখ করা হয়; একই bus-এর সব node-এ এটি কাছাকাছি হওয়া জরুরি। বাজারঘরের board-এর মতো 8 MHz clock আর 125 kbit/s-এর একটি সহজ হিসাব অনুশীলন ৪-এ।
CAN FD, CAN XL আর ওপরের protocol
Classical CAN-এর দুই সীমা: frame-এ মাত্র ৮ byte, আর পুরো frame একই ধীর bit rate-এ, কারণ arbitration-এর জন্য তারের দৈর্ঘ্যের সীমা মানতে হয়। CAN FD (flexible data-rate, Bosch ২০১২, ISO 11898-1:2015) দুটোই বদলায়। Arbitration অংশ আগের মতো ধীর থাকে, কিন্তু BRS (bit rate switch) বিট দিলে data অংশ অনেক দ্রুত bit rate-এ চলে, কারণ তখন একজনই পাঠাচ্ছে আর তারের round trip-এর দরকার নেই। Data ৬৪ byte পর্যন্ত: DLC 9–15-এর অর্থ 12, 16, 20, 24, 32, 48 আর 64 byte. লম্বা data-র জন্য CRC-ও লম্বা: ১৬ byte পর্যন্ত CRC-17, তার বেশি হলে CRC-21. নতুন বিট FDF frame-কে FD হিসেবে চেনায়। পুরোনো classical controller FD frame-এ error frame দেয়, তাই মেশানো bus-এ সতর্কতা লাগে (ভাবনার প্রশ্ন ৪)। পরের প্রজন্ম CAN XL (CiA-র কাজ) আরও বড় data আনে; তার সংখ্যা উৎস দেখে নেবেন।
CAN নিজে শুধু frame পৌঁছায়; data-র অর্থ, ID-র বণ্টন আর বড় বার্তা টুকরো করে পাঠানোর নিয়ম ওপরের protocol ঠিক করে। কয়েকটি নাম যা আপনি শুনবেন: শিল্প-যন্ত্রে CANopen (CiA-র মান), ট্রাক আর কৃষি-যন্ত্রে SAE J1939 (২৯ বিটের ID), গাড়ির রোগনির্ণয়ে OBD-II-এর CAN রূপ (ISO 15765). আর একটি গুরুত্বপূর্ণ সীমা: classical CAN-এ কোনো প্রমাণীকরণ নেই। তারে যুক্ত যেকোনো node যেকোনো ID পাঠাতে পারে, আর গ্রাহক জানে না সেটি আসল প্রেরকের কি না। নিরাপত্তার জন্য তাই bus ভাগ করা, মাঝে gateway-এ নিয়ম, আর বার্তায় cryptographic প্রমাণ যোগ করা হয় (পর্ব ৭৬; সাধারণ নিরাপত্তা Cybersecurity পর্ব ৩৫-এ)।
| বিষয় | Classical CAN | CAN FD |
|---|---|---|
| Data | 0–8 byte | 0–64 byte (DLC 9–15 = 12 … 64) |
| Bit rate | পুরো frame একই, 1 Mbit/s পর্যন্ত | Arbitration ধীর, data অংশ দ্রুত (BRS) |
| CRC | CRC-15 | CRC-17 বা CRC-21 |
| Remote frame | আছে | নেই |
| বাজারঘরের গুদামে | যথেষ্ট: ছোট বার্তা, কম load | দরকার নেই; firmware update-এর মতো বড় data হলে ভাবার বিষয় |
আরও গভীরে: Arbitration-এর “জয়ী অক্ষত” গুণ আসে physical layer-এর একটি শর্ত থেকে: প্রতিটি node-কে প্রতিটি বিটের sample point-এ সবচেয়ে দূরের node-এর বিট দেখতে হবে। তাই bit timing-এর propagation segment-এ তারের দুই দিকের যাত্রা আর দুই transceiver-এর দেরি ধরতে হয়, আর এই কারণেই classical CAN দৈর্ঘ্য আর গতির মধ্যে আটকে থাকে। CAN FD এই বাঁধন শুধু arbitration অংশে রাখে; data অংশে প্রেরকের নিজের transceiver-এর দেরি মাপতে “transmitter delay compensation” ব্যবহার হয়। এজন্য CAN FD controller-এ arbitration আর data অংশের জন্য দুটি আলাদা bit timing ঠিক করতে হয়।
পরীক্ষা ও ইন্টারভিউতে: “দুটি node 0x123 আর 0x122 একসাথে পাঠালে কে জেতে?” → 0x122, ছোট ID; ID0-এ 0 বনাম 1. “Dominant আর recessive কোনটি 0?” → dominant = 0; wired-AND-এ 0 জেতে। “Bit stuffing কেন?” → NRZ-এ কিনারা নিশ্চিত করে ঘড়ি মেলাতে, আর ছয়টি একই বিটকে error flag-এর জন্য খালি রাখতে। “TEC কত হলে bus-off?” → 256 বা বেশি; error-passive 128-এ। “Bus-এ একা node কেন bus-off হয় না?” → error-passive হলে ACK error-এ TEC আর বাড়ে না।
৮ · AI-এর যুগে CAN-এর কোড আর হিসাব যাচাই
AI assistant-এর কাছে “STM32-এ CAN-এ একটি বার্তা পাঠানোর কোড” চাইলে প্রায়ই চলনসই কোড আসে, কিন্তু CAN-এর ভুলগুলো compile-এ ধরা পড়ে না: ভুল bit timing-এ bus-এ শুধু error frame, ভুল filter-এ নীরবতা। পরিচিত ভুল আর ধরার উপায়:
| AI প্রায়ই যা করে | কীভাবে ধরবেন |
|---|---|
| Dominant-কে 1 বলে, বা “বড় ID বেশি জরুরি” বলে | Wired-AND-এর নিয়ম থেকে নিজে একটি arbitration চালানো (এই পর্বের মডেল) |
| Bit timing-এর prescaler আর segment অনুমানে দেয়, clock-এর মান না জেনে | Peripheral clock থেকে হাতে হিসাব: bit rate = clock ÷ (prescaler × tq-সংখ্যা); sample point-এর শতাংশ |
| এক chip-এর register বা HAL function অন্য chip-এর বলে দেয় (bxCAN, FDCAN, MCP2515 মিশিয়ে) | নিজের chip-এর reference manual-এর CAN অধ্যায়; কোন peripheral আছে datasheet-এ দেখা |
| Filter বন্ধ রেখে সব বার্তা ISR-এ নেয়, ISR-এ printf বা দীর্ঘ কাজ | Filter নকশা কাগজে; ISR শুধু FIFO থেকে ring buffer-এ (পর্ব ৪৩) |
| Termination, transceiver বা bus-off ফেরার নীতির কথা বাদ দেয় | Hardware-এর চেকলিস্ট: দুই প্রান্তে 120 Ω, transceiver, bus-off-এর পরে কী হবে |
| “CAN নিরাপদ” বা “CAN-এ encryption আছে” বলে | Classical CAN-এ প্রমাণীকরণ নেই; নিরাপত্তা ওপরের স্তরে আর gateway-তে |
প্রসঙ্গ আর যাচাইয়ের শর্ত শুরুতেই দিন:
AI-এর উত্তর হাতে পেলে — যাচাইয়ের চেকলিস্ট
ভাবনার প্রশ্ন
প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন, তারপর “→ উত্তর” চাপুন।
প্র ০১Bosch কেন node-এর ঠিকানার বদলে বার্তার ID বেছে নিল? এই সিদ্ধান্তের ভালো আর কঠিন দিক কী?
১৯৮০-এর দশকের গাড়িতে একই তথ্য অনেকের দরকার হতো: engine-এর গতি লাগে gearbox-এর, ড্যাশবোর্ডের আর ABS-এর। ঠিকানা-ভিত্তিক ব্যবস্থায় প্রেরককে প্রতিটি প্রাপকের কাছে আলাদা করে পাঠাতে হতো, আর নতুন একটি ECU যোগ করলে পুরোনো প্রেরকের firmware বদলাতে হতো। বার্তা-ভিত্তিক নকশায় engine ECU একবার “engine-এর গতি” ID-তে পাঠায়; কে শুনবে, তা প্রত্যেক গ্রাহক নিজের filter-এ ঠিক করে। একই তথ্য একই মুহূর্তে সবার কাছে যায়, তাই সব ECU-র ছবি এক থাকে, যা ব্রেক আর stability নিয়ন্ত্রণে জরুরি।
দ্বিতীয় লাভ অগ্রাধিকার। ID-ই arbitration-এর চাবি, তাই “বার্তাটি কী” আর “কতটা জরুরি” একই সংখ্যায় বাঁধা, আর bus-এর আচরণ নকশার সময়েই বিশ্লেষণ করা যায়। বাজারঘরের গুদামে alarm-কে 0x051–0x053 দিয়ে তাপমাত্রার 0x101–0x103-এর ওপরে রাখা ঠিক এই চিন্তা।
কঠিন দিকও আছে। ID-র তালিকা পুরো ব্যবস্থার একটি কেন্দ্রীয় দলিল হয়ে যায়: কোন ECU কোন ID পাঠায়, data-র অর্থ কী, কত ঘন ঘন। ভুল তালিকায় দুই ECU একই ID পেলে মাঝে মাঝে ঘটা অদ্ভুত ভুল আসে। “কে পাঠাল” তথ্য frame-এ নেই, যা নিরাপত্তার দুর্বলতা (প্রশ্ন ৫)। আর পরে কোনো বার্তাকে বেশি জরুরি করতে চাইলে তার ID বদলাতে হয়, অর্থাৎ সব গ্রাহকের filter-ও। বড় ব্যবস্থায় এসব সামলাতেই CANopen বা J1939-এর মতো ওপরের মান ID-র বণ্টনের নিয়ম দেয়।
মূল উপলব্ধি: ID-ভিত্তিক broadcast নতুন node যোগ করা সহজ আর অগ্রাধিকার পূর্বানুমেয় করে; তার দাম একটি সাবধানে রক্ষা করা ID-র তালিকা আর “কে পাঠাল” তথ্যের অভাব।
প্র ০২Ethernet-এর CSMA/CD আর CAN-এর arbitration দুটোই “শুনে তারপর বলা”। তবু real-time নিয়ন্ত্রণে CAN কেন জনপ্রিয় হলো, আর তার মূল্য কী?
ক্লাসিক half-duplex Ethernet-এ দুই station একসাথে পাঠালে দুজনের সংকেতই নষ্ট হয়; দুজনই থামে, এলোমেলো সময় অপেক্ষা করে আবার চেষ্টা করে। গড়ে এটি ভালো, কিন্তু সবচেয়ে খারাপ দেরির সীমা নেই। CAN-এ সংঘর্ষ ধ্বংসাত্মক নয়: wired-AND-এর কারণে তারের বিট জয়ীর বিটের সমান, তাই জয়ীর frame বা সময় কিছুই নষ্ট হয় না, আর হেরে যাওয়াদের ক্রমও ID দিয়ে নির্দিষ্ট।
এই নির্দিষ্টতাই real-time বিশ্লেষণ সম্ভব করে। ১৯৯০-এর দশকের শুরুতে Ken Tindell ও Alan Burns প্রমুখ CAN-এ fixed-priority-র response-time বিশ্লেষণ প্রয়োগ করেন বলে সাধারণত বলা হয়: প্রতিটি বার্তা একটি task, blocking একটি লম্বা কম-জরুরি frame, interference বেশি-জরুরি বার্তাগুলো। ২০০৭ সালে Robert Davis ও সহকর্মীরা মূল বিশ্লেষণের একটি সূক্ষ্ম ত্রুটি দেখিয়ে সংশোধিত রূপ প্রকাশ করেন। পর্ব ৫৬-এর rate-monotonic চিন্তার সঙ্গে মিল লক্ষ করুন; এই পর্বের ১৫৪৪ µs-এর হিসাব সেই বিশ্লেষণের সরলতম রূপ।
মূল্য তিনটি। তারের দৈর্ঘ্য আর গতি বাঁধা: প্রতিটি বিটে সবচেয়ে দূরের node-এর সংকেত ফিরে আসতে হয়, তাই 1 Mbit/s-এ কয়েক দশ মিটার। প্রতি frame-এ overhead বেশি: আট byte-এর জন্য ৪৪টি নিয়ন্ত্রণ বিট আর stuffing. আর fairness নেই: খুব ঘন ঘন পাঠানো একটি ছোট ID বাকিদের আটকে রাখতে পারে, তাই প্রতিটি বার্তার হার নকশায় সীমিত রাখতে হয়। আধুনিক গাড়িতে তাই CAN আর Ethernet পাশাপাশি থাকে বলে বর্ণনা পাওয়া যায়: ছোট নিয়ন্ত্রণ-বার্তা CAN-এ, ক্যামেরার বড় data Ethernet-এ।
মূল উপলব্ধি: Non-destructive arbitration সংঘর্ষকে অগ্রাধিকারের সিদ্ধান্তে বদলে দেয়, যা real-time বিশ্লেষণ সম্ভব করে; বিনিময়ে CAN গতি, দৈর্ঘ্য আর fairness ছাড়ে।
প্র ০৩TEC-এ ভুলে +8 আর সাফল্যে −1 কেন? “babbling idiot” সমস্যা আর একা node-এর ব্যতিক্রম দিয়ে ব্যাখ্যা করুন।
Shared bus-এর সবচেয়ে বড় ভয়: একটি খারাপ node পুরো ব্যবস্থা নামিয়ে দেবে। Transceiver ভাঙলে বা oscillator ভুল হলে node-টি প্রতিটি frame-এ error flag দিতে বা নিজের প্রতিটি frame-এ bit error পেয়ে আবার পাঠাতে পারে; কেউ না থামালে bus-এ শুধু error frame চলবে। সাহিত্যে একে “babbling idiot” বলা হয়। Fault confinement-এর লক্ষ্য: সমস্যা যে node-এ, তাকেই আলাদা করা।
+8 আর −1-এর অসমতা একটি সরল পরিসংখ্যানিক ফাঁদ। ভালো node-এ ভুল বিরল: প্রতিটি ভুলের পরে অনেক সফল frame TEC এক করে কমায়, তাই counter শূন্যের কাছে থাকে। আটটির মধ্যে একটির বেশি পাঠানো ব্যর্থ হলে counter বাড়তেই থাকে। এই পর্বের মডেলে ভাঙা T3 ১৬টি ব্যর্থতায় error-passive হলো, তখন তার error flag recessive, অন্যদের frame নষ্ট করে না; ৩২টিতে bus-off. খারাপ node নিজেকে নিজেই নিঃশব্দ করে, বাইরের নিয়ন্ত্রক ছাড়া। নিয়ম ২ (flag-এর পরের প্রথম বিটে dominant দেখলে +8) সেই গ্রাহককে বেশি দায়ী করে, যে একা প্রথম ভুল দেখেছে, কারণ তা প্রায়ই নিজের সমস্যার লক্ষণ।
একা node-এর ব্যতিক্রম বাস্তব পরিস্থিতি থেকে। চালু হওয়ার সময় একটি node আগে জেগে পাঠাতে পারে, কেউ ACK দেয় না; নিয়ম না থাকলে নির্দোষ node-টি ৩২টি চেষ্টায় bus-off হতো। ব্যতিক্রম ১-এর কারণে সে 128-এ অপেক্ষা করে। Bus-off থেকে ফেরার শর্ত, 128 বার 11টি recessive, নিশ্চিত করে bus সত্যি শান্ত। একটি বৈচিত্র্য: Bosch-এর M_CAN IP-র একটি application note বলে সেই controller 129 বার অপেক্ষা করে, তাই নির্দিষ্ট chip-এর manual দেখতে হয়।
মূল উপলব্ধি: অসম counter বিরল ভুল ক্ষমা করে আর বারবারের ভুল জমিয়ে খারাপ node-কে নিজেই সরিয়ে দেয়; ব্যতিক্রমগুলো নির্দোষ node-কে, যেমন একা জেগে ওঠা node-কে, বাঁচায়।
প্র ০৪CAN FD কেন এলো, আর একটি পুরোনো classical CAN node-এর জন্য একই bus-এ FD frame কেন সমস্যা?
২০০০-এর দশকে গাড়ির ECU আর software দুটোই অনেক বেড়েছে: driver-assistance-এর sensor-এর বড় data, আর ECU-র firmware update. Classical CAN-এ প্রতি frame-এ ৮ byte আর প্রায় অর্ধেক কার্যকর হার (অংশ ৫-এর ৪৭–৫৮%) এই কাজে ধীর, আর bit rate বাড়ালে arbitration-এর round trip-এর কারণে তারের দৈর্ঘ্য আরও কমে। Bosch-এর পর্যবেক্ষণ: round trip দরকার শুধু arbitration-এ; জয়ী ঠিক হলে একজনই পাঠায়, তখন বিট ছোট করা যায়। তাই ২০১২ সালের CAN FD একই frame-এ দুটি গতি রাখে আর data ৬৪ byte পর্যন্ত বাড়ায়।
লম্বা data-র সঙ্গে CRC বদলাতে হয়েছে: একটি CRC কত ভুল নিশ্চিত ধরবে, তা দৈর্ঘ্যের ওপর নির্ভর করে, আর Bosch spec নিজেই বলে CRC-15 ১২৭ বিটের কম frame-এর জন্য উপযোগী BCH code. তাই ৬৪ byte-এ CRC-21. ISO মানে আনার সময় stuff বিট নিয়ে একটি বিরল দুর্বলতা পাওয়া যায় বলে বর্ণনা আছে, আর ISO CAN FD stuff বিটের সংখ্যা আলাদা field-এ পাঠিয়ে আর CRC-র শুরুর মান বদলে তা সারায়; এজন্য বাজারে ISO আর non-ISO CAN FD-এর কথা শোনা যায়, যারা একে অপরের সঙ্গে চলে না।
পুরোনো node-এর সমস্যা সরাসরি। Classical controller-এর কাছে FDF বিটটি একটি সংরক্ষিত বিটের জায়গায় পড়ে, কিন্তু তার পরের দ্রুত বিট আর লম্বা data-র সঙ্গে তার হিসাব মেলে না; কিছু পরে সে stuff বা form error ধরে error flag দেয়, আর error-active থাকলে প্রতিটি FD frame নষ্ট করে। মেশানো bus-এ তাই হয় সব node FD-সহনশীল, নয়তো পুরোনোগুলোকে FD frame-এর সময় চুপ রাখা, বা bus ভাগ করে মাঝে gateway. বাজারঘরের ছোট বার্তায় classical CAN যথেষ্ট; CAN দিয়েই node-এর firmware update (পর্ব ৭৭) করতে চাইলে FD-এর হিসাব আসবে।
মূল উপলব্ধি: CAN FD arbitration-এর ধীর বিট রেখে data অংশ দ্রুত আর বড় করে; বড় data-র জন্য লম্বা CRC লাগে, আর পুরোনো node নতুন frame-কে ভুল ভেবে নষ্ট করে বলে মেশানো bus সাবধানে নকশা করতে হয়।
প্র ০৫CAN-এ প্রমাণীকরণ নেই। গাড়ির নিরাপত্তা গবেষণা এ বিষয়ে কী শিখিয়েছে, আর একজন নকশাকার কীভাবে প্রতিরক্ষা গড়েন?
CAN-এর জন্ম একটি বন্ধ ব্যবস্থার জন্য: গাড়ির ভেতরের তার, যেখানে সব ECU বিশ্বস্ত ধরা হতো। Frame-এ প্রেরকের পরিচয় নেই, ID যে কেউ পাঠাতে পারে, encryption নেই। ২০১০ সালের দিকে Koscher ও সহকর্মীরা (IEEE Security and Privacy সম্মেলন) দেখান, গাড়ির bus-এ পৌঁছানো গেলে অনেক ECU-র আচরণে প্রভাব ফেলা যায়। ২০১৫ সালে Charlie Miller আর Chris Valasek-এর বহুল আলোচিত গবেষণায় একটি গাড়ির infotainment ব্যবস্থা দিয়ে দূর থেকে সেই bus-এ পৌঁছানো দেখানো হয়, যার পরে নির্মাতা ব্যাপক recall করে বলে প্রতিবেদন আছে। শিক্ষা: bus বাইরের জগতের সঙ্গে কোনো পথে যুক্ত হলেই “ভেতরের সবাই বিশ্বস্ত” ধারণা আর চলে না।
প্রতিরক্ষা কয়েক স্তরে। ভাগ করা: নিরাপত্তা-সংবেদনশীল ECU আলাদা bus-এ, মাঝে একটি gateway যা শুধু অনুমোদিত ID আর হার পার হতে দেয়। প্রমাণ: বার্তায় একটি ছোট message authentication code আর পুনরাবৃত্তি ঠেকানোর counter, যেমন AUTOSAR-এর SecOC নির্দেশিকায় বর্ণিত; classical CAN-এর ৮ byte-এ কঠিন, CAN FD-তে সহজ। নজরদারি: প্রতিটি ID-র স্বাভাবিক হার জেনে অস্বাভাবিকতা ধরা। আর ECU-র নিজের সুরক্ষা: secure boot আর স্বাক্ষরিত firmware update (পর্ব ৭৭)।
বাজারঘরের গুদামে ঝুঁকি কম, কিন্তু চিন্তা একই। Gateway-ই একমাত্র node যা internet-এ যুক্ত, তাই সেখানেই কড়াকড়ি: dashboard-এর কোনো আদেশ সরাসরি CAN-এ নয়, শুধু নির্দিষ্ট, যাচাই করা আদেশ; compressor এমন আদেশ মানবে না যা তাপমাত্রাকে নিরাপদ সীমার বাইরে নেয়। এই আলোচনার উদ্দেশ্য প্রতিরক্ষা বোঝা; অনুমতি ছাড়া আসল গাড়ি বা যন্ত্রে পরীক্ষা বেআইনি আর বিপজ্জনক।
মূল উপলব্ধি: CAN বিশ্বাসের ওপর নকশা করা; বাইরের সংযোগ এলে নিরাপত্তা আসে bus ভাগ করা, gateway-এর নিয়ম, বার্তার প্রমাণ আর ECU-র নিজের সুরক্ষা থেকে, CAN নিজে থেকে নয়।
অনুশীলন
প্রথমে নিজে লিখুন বা হিসাব করুন, তারপর উত্তর খুলুন। প্রতিটি উত্তর Python মডেলে বা কোর্সের virtual board-এ চালিয়ে যাচাই করা।
-
নকশা — COMP-এর receive filter: একটি CAN controller-এর filter নিয়ম: ID রাখা হবে যদি (ID AND mask) = (filter AND mask). COMP শুধু তিন ঘরের তাপমাত্রা (0x101–0x103) আর alarm (0x051–0x053) চায়, আর দুটি filter ব্যবহার করতে পারে। প্রতিটির mask আর মান দিন, আর বলুন অন্য কোনো ID ঢুকে পড়ে কি না। তারপর C-তে একটি
int accept(uint16_t id)লিখুন।0x101, 0x102, 0x103 শুধু শেষ দুই বিটে আলাদা। তাই mask = 0x7FC (11111111100), শেষ দুই বিট “যা খুশি”। Filter ১: মান 0x100. Filter ২: মান 0x050, একই mask. Python-এ সব ID চালিয়ে দেখা গেছে filter ১ রাখে 0x100, 0x101, 0x102, 0x103, আর filter ২ রাখে 0x050–0x053. অর্থাৎ 0x100 আর 0x050-ও ঢোকে। আমাদের ID-তালিকায় এ দুটি ব্যবহার হয় না বলে ক্ষতি নেই, কিন্তু তালিকায় লিখে রাখতে হবে যে এ দুটি “সংরক্ষিত”, নইলে পরে কেউ ব্যবহার করলে COMP অপ্রয়োজনে সেগুলো পাবে।
int accept(uint16_t id) { return ((id & 0x7FCu) == 0x100u) || /* 0x100..0x103 */ ((id & 0x7FCu) == 0x050u); /* 0x050..0x053 */ }আসল hardware filter এই কাজ বিট-স্তরে, CPU-র কোনো সময় না নিয়ে করে; firmware-এর এই function test-এর জন্য বা filter-হীন controller-এ software filter হিসেবে কাজে লাগে।
-
ভুল খুঁজুন — stuffing-এর একটি সূক্ষ্ম bug: একজন CAN simulator-এর stuffing এভাবে লিখেছেন:
ID 0x101, data 04 00-এর frame-এ ফল ঠিক আসে। কিন্তু ID 0x101, data 02 0F-এর frame তারে গেলে একজন সঠিক গ্রাহক কী ভুল ধরবে, আর কেন? ঠিক রূপ কী?out[m++] = in[i]; run = (in[i] == last) ? run + 1 : 1; last = in[i]; if (run == 5) { out[m++] = !last; run = 0; } /* stuff */Bug: stuff বিট বসানোর পরে
lastআগের মানেই থাকে আরrunশূন্য হয়, অর্থাৎ stuff বিটকে পরের সারির প্রথম বিট ধরা হয় না। নিয়ম ২ (অংশ ৪) ভাঙা। 0x02 0x0F-এর frame-এ data-র ভেতরে 00000-এর পরে stuff 1, তারপর data-তে আরও চারটি 1 আর একটি 1: সঠিক প্রেরক stuff 1 + 1111 = পাঁচটি 1-এর পরে একটি 0 বসাত; bug-ওয়ালা প্রেরক বসায় না। ফলে তারে ছয়টি 1 পরপর। Python মডেলে চালিয়ে: সঠিক গ্রাহক তারের index 39-এ stuff error ধরে, error frame দেয়, আর frame কখনো পৌঁছায় না। 0x04 0x00-এর frame-এ এমন সারি নেই, তাই সেখানে ভুল লুকিয়ে ছিল: একটি test vector কখনো যথেষ্ট নয়।ঠিক রূপ:
if (run == 5) { out[m++] = !last; last = !last; run = 1; }, যা board-এ চালানোcan_crc.c-তে আছে। আরেকটি সতর্কতা: অন্য কিছু frame-এ এই bug stuff error না দিয়ে গ্রাহককে একটি আসল data বিট stuff ভেবে মুছতে বাধ্য করে, তখন ভুল ধরা পড়ে CRC error হিসেবে। -
হিসাব — arbitration আর সময়: (ক) তিনটি node একসাথে standard ID 0x65A, 0x659 আর 0x6A0 পাঠাতে শুরু করল। কে জেতে, আর বাকি দুজন কোন ID বিটে হারে? (খ) 500 kbit/s-এ ৮ byte data-র একটি standard data frame সবচেয়ে খারাপ ক্ষেত্রে (সর্বোচ্চ stuffing, intermission-সহ) কত µs নেয়?
(ক) Binary: 0x65A = 110 0101 1010, 0x659 = 110 0101 1001, 0x6A0 = 110 1010 0000. ID10, ID9, ID8 তিনজনেরই 110. ID7-এ 0x65A আর 0x659-এর 0, 0x6A0-এর 1: 0x6A0 হারে ID7-এ। তারপর ID6–ID2 দুজনের এক (10110); ID1-এ 0x659-এর 0, 0x65A-এর 1: 0x65A হারে। জয়ী 0x659, সবচেয়ে ছোট। Python মডেলে চালালে stuff বিটসহ তারের index-এ হার বিট 4 আর বিট 10-এ আসে; এই ID-গুলোর প্রথম অংশে পাঁচটি একই বিট নেই, তাই index = ID-র অবস্থান। (খ) ৮ byte: 44 + 64 = 108 বিট, সর্বোচ্চ stuff ⌊(34 + 64 − 1) ÷ 4⌋ = 24, intermission 3: মোট 135 বিট। 500 kbit/s-এ এক বিট 2 µs, তাই 270 µs.
-
আগে বলুন — counter আর bit timing: (ক) একটি node-এর TEC 0. পরপর তিনবার পাঠানোয় bit error, তারপর পাঁচটি সফল পাঠানো। TEC কত, আর অবস্থা কী? (খ) CAN-এর clock 8 MHz, চাই 125 kbit/s, প্রতি বিটে 16 tq: prescaler কত, এক tq কত? Sync 1 tq, phase segment 2 = 2 tq হলে sample point কত শতাংশে? (গ) 250 kbit/s-এ bus-off থেকে ফেরার সর্বনিম্ন সময় কত?
(ক) 3 × 8 = 24, তারপর 5 × (−1): TEC = 19, error-active (127-এর নিচে)। (খ) এক বিট = 1 ÷ 125000 = 8 µs; 16 tq-এ এক tq = 0.5 µs = 4টি 8 MHz-এর clock, তাই prescaler 4. যাচাই: 8 MHz ÷ (4 × 16) = 125000. Sync 1 + phase segment 1 পর্যন্ত বাকি 13 tq + phase segment 2-এর 2 tq = 16; sample point 14-তম tq-এর শেষে: 14 ÷ 16 = 87.5%. (গ) 128 × 11 = 1408 বিট, 250 kbit/s-এ 4 µs করে: 5.632 ms. সব সংখ্যা Python-এ চালিয়ে মেলানো।
নিজেকে যাচাই করুন
ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।
ক্রমএকটি CAN node একটি data frame পাঠাচ্ছে। ঘটনাগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)
- Bus খালি (intermission-এর পরে recessive) দেখে SOF পাঠানো
- ID-র প্রতিটি বিট পাঠিয়ে তার শোনা, আর অমিল হলে সরে যাওয়া (arbitration)
- Control field, data আর CRC পাঠানো, পাঁচটি একই বিটের পরে stuff বিটসহ
- CRC delimiter-এর পরে ACK slot-এ গ্রাহকের dominant বিট শোনা
- সাতটি recessive-এর EOF, তারপর intermission
দুটি CAN node একই মুহূর্তে standard ID 0x123 আর 0x122-এর data frame পাঠাতে শুরু করল। কী ঘটবে?
- দুটি frame-ই নষ্ট হবে, দুজন এলোমেলো সময় পরে আবার চেষ্টা করবে
- 0x122 জিতবে; 0x123 ID0-এ হেরে গ্রাহক হবে আর পরে আবার চেষ্টা করবে
- 0x123 জিতবে, কারণ তার ID বড়
- দুজনই bit error ধরে error frame পাঠাবে
Classical CAN-এর data frame-এ bit stuffing কোন অংশে প্রয়োগ হয়?
- পুরো frame-এ, SOF থেকে EOF পর্যন্ত
- শুধু data field-এ
- SOF থেকে CRC sequence-এর শেষ পর্যন্ত
- শুধু পাঁচটি টানা 1-এর পরে, পুরো frame-এ
High-speed CAN-এ (ISO 11898-2) একটি recessive বিটে দুই তারের অবস্থা কোনটি?
- CAN_H আর CAN_L প্রায় একই voltage-এ (প্রায় 2.5 V), পার্থক্য প্রায় 0 V
- CAN_H প্রায় 3.5 V, CAN_L প্রায় 1.5 V
- CAN_H 5 V, CAN_L মাপা হয় না
- CAN_H প্রায় 1.5 V, CAN_L প্রায় 3.5 V
একটি বন্ধ CAN bus-এ CAN_H আর CAN_L-এর মাঝে resistance মাপা হলো প্রায় 120 Ω. সবচেয়ে সম্ভাব্য অর্থ কী?
- দুই প্রান্তের terminator ঠিক আছে
- একটি বাড়তি terminator মাঝখানে বসানো
- CAN_H আর CAN_L শর্ট হয়ে আছে
- একটি প্রান্তের terminator নেই বা সংযোগ খোলা
একটি CAN node-এর TEC 120, REC 0. তার পরের পাঠানোয় bit error হলো (কোনো ব্যতিক্রম খাটে না)। নতুন অবস্থা কী?
- TEC 120-ই থাকে, error-active
- TEC 128, error-passive
- TEC 128, bus-off
- TEC 121, error-active
Standard format-এর একটি data frame-এ ২ byte data. SOF থেকে EOF পর্যন্ত, stuff বিট ছাড়া, frame কত বিটের?
- 50
- 63
- 60
- 80
শব্দকোষ
লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:
মনে রাখুন
- তার: CAN_H আর CAN_L-এর পার্থক্যে তথ্য; recessive (1) ≈ 0 V পার্থক্য, dominant (0) ≈ 2 V; wired-AND, তাই 0 জেতে। দুই প্রান্তে 120 Ω, মাপলে 60 Ω.
- Frame: SOF, ID (১১ বা ২৯ বিট), RTR/IDE, DLC, ০–৮ byte, CRC-15 (0x4599), ACK, EOF; stuffing ছাড়া 44 + 8n বিট (standard). ACK মানে অন্তত একজন ঠিক পেয়েছে।
- Stuffing আর CRC: পাঁচটি একই বিটের পরে উল্টো বিট, SOF থেকে CRC পর্যন্ত, stuff বিটও গোনায়; CRC হয় stuff ছাড়া বিটে। সবচেয়ে খারাপ ৮ byte-এ ২৪টি stuff.
- Arbitration: ছোট ID জেতে, জয়ীর frame অক্ষত; ID অনন্য হতে হবে। সবচেয়ে জরুরি বার্তার সবচেয়ে খারাপ অপেক্ষা ≈ একটি লম্বা frame + নিজের frame.
- ভুল: পাঁচ ধরনের ভুল, error flag ছয়টি dominant; TEC +8/−1, REC +1/−1; 128-এ error-passive, 256-এ bus-off; একা node 128-এ থামে। CAN FD: ৬৪ byte আর দ্রুত data অংশ।
আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ
- মাইক্রোপ্রসেসর, এমবেডেড সিস্টেম ও IoT · কোর্স হোম৮৫টি পর্বপুরো কোর্সের মানচিত্র আর বাজারঘরের দুটি device-এর পথ।
- পর্ব ৪১ · GPIO, pull-up আর open-drainআগের ভিত্তিWired-AND: dominant আর recessive-এর মূল ধারণা।
- পর্ব ৪৩ · Interrupt আর ISR নকশাআগের ভিত্তিCAN-এর receive FIFO থেকে ছোট ISR আর ভাগ করা data.
- পর্ব ৫১ · I2Cআগের পর্বআরেকটি open-drain bus, যেখানে একাধিক master-এর arbitration-ও wired-AND-এ চলে।