এই পর্বে যা শিখবেন
- REST-এর resource আর method দিয়ে একটি IoT যন্ত্রের ঠিকানা-তালিকা নকশা করা
- CoAP-এর বার্তা byte ধরে পড়া আর হাতে বানানো: header, token, option আর payload
- CON, NON, ACK আর RST, message ID আর token, আর retransmission-এর সময় হিসাব করা
- Observe আর block-wise transfer কোন সমস্যার সমাধান, তা বলা
- একই কাজ HTTP/1.1-এ কত byte নেয় গুনে, MQTT, CoAP আর HTTP-র মধ্যে কারণসহ বাছাই করা
১ · ছোট যন্ত্রেও REST — resource, method আর বাজারঘরের ঠিকানা
পর্ব ৭৩-এ telemetry গেছে MQTT-র broker দিয়ে: cold room বার্তা ছেড়ে দেয়, যে চায় সে পায়। কিন্তু সব কাজ এমন নয়। গুদামের technician ল্যাপটপ থেকে জানতে চান “ঘর ১-এর তাপমাত্রা এখন কত?”, বা মালিক বলেন “high সীমা 8.50 করে দিন”। এখানে দরকার প্রশ্ন আর উত্তর, নির্দিষ্ট একটি যন্ত্রের সঙ্গে। এই ধাঁচের সবচেয়ে পরিচিত নিয়ম REST, যা ওয়েবের HTTP-তে চলে; আর ছোট যন্ত্রের জন্য তার হালকা রূপ CoAP. এই পর্বে hex লেখা হবে C-ধাঁচে, 0x…, আর বার্তার byte দুই অঙ্কের জোড়ায় (42 01 af 2e).
REST-এর মূল কথা দুটি। এক, প্রতিটি জিনিস একটি resource, যার একটি ঠিকানা আছে, যেমন /coldroom/1/temp. দুই, কাজ হাতে-গোনা কয়েকটি, সব resource-এ একই: পড়া (GET), বদলানো (PUT), নতুন কিছু পাঠানো (POST), মোছা (DELETE). এই কাজগুলোকে বলে method. প্রতিটি অনুরোধ নিজের মধ্যে সম্পূর্ণ, server আগের অনুরোধ মনে রাখে না। Network-এর দিক থেকে HTTP-র বিস্তারিত Computer Networks পর্ব ৩৬-এ, আর API নকশার নিয়ম System Design পর্ব ০৮-এ; এখানে শুধু IoT-এর দিক।
উপমা — চিরকুট বনাম অফিসের চিঠি: গুদামের দারোয়ানকে একটি ছোট চিরকুট দিলেন: “ঘর ১, তাপ?” উত্তর এল আরেকটি চিরকুটে: “7.00, HIGH”. এটি CoAP. একই প্রশ্ন অফিসের letterhead-এ, তারিখ, প্রেরকের নাম আর বিষয়সহ খামে ভরে পাঠালে সেটি HTTP: কথা একই, মোড়ক অনেক বড়। আর রেজিস্ট্রি ডাকের মতো প্রাপ্তিস্বীকার চাইলে CoAP-এ বার্তা পাঠান “confirmable” করে; প্রাপ্তিস্বীকার না এলে আবার পাঠান।
বাজারঘরের cold room monitor-কে একটি ছোট server ভাবুন। কোর্সের reference lab-এর coap_check.py ঠিক এই resource-গুলো বানায় (Spec decision 40), আর নিচের HTTP-র run একই ঠিকানা ব্যবহার করে:
| Resource | Method | CoAP-এর উত্তর | HTTP-র উত্তর |
|---|---|---|---|
/coldroom/1/temp | GET | 2.05 Content, JSON (57 byte) | 200 OK |
/coldroom/1/limit | PUT 8.50 | 2.04 Changed | 204 No Content |
/coldroom/1/limit | GET | 2.05 Content, 8.50 | 200 OK |
/nothing | GET | 4.04 Not Found | 404 Not Found |
JSON payload-টি firmware-এর telemetry-র হুবহু লেখা: {"dev":"coldroom-1","seq":1,"temp_c":7.00,"alarm":"HIGH"} (reference lab-এর test এটি মিলিয়ে দেখে)। আর 8.50 শুধু একটি উদাহরণ; বাজারঘরের নির্ধারিত high সীমা 8.00 °C. একটি কথা সৎভাবে মনে রাখুন: কোর্সের virtual “বাজারঘর board” (BG-M3), আসল Cortex-M chip-এর আদলে বানানো, তার কোনো radio বা network নেই। তাই এই পর্বের সব run চলে একটি কম্পিউটারের ভেতরে, 127.0.0.1-এ; radio-র জায়গায় loopback.
মূল নিয়ম REST একটি নকশার ধাঁচ, protocol নয়। HTTP আর CoAP দুটিই সেই ধাঁচ মানে; পার্থক্য মোড়কের ওজনে, transport-এ (TCP বনাম UDP) আর নিশ্চয়তা কে দেয় তাতে।
২ · CoAP-এর বার্তা — 4 byte header, token, option আর payload
CoAP-এর পুরো নাম Constrained Application Protocol. IETF-এর CoRE (Constrained RESTful Environments) দল এটি তৈরি করে, আর জুন ২০১৪-এ RFC 7252 হিসেবে প্রকাশ হয় (লেখক Zach Shelby, Klaus Hartke আর Carsten Bormann). চলে UDP-র ওপর, প্রচলিত port 5683, আর নিরাপদ রূপ coaps চলে DTLS-এর ওপর, port 5684. প্রতিটি CoAP বার্তা একটি UDP datagram-এ এঁটে যায়।
ছবি ৭৪.১ — CoAP বার্তার গঠন, ঠান্ডা ঘরের GET দিয়ে
প্রথম 4 byte সবসময় থাকে; বাকিগুলো দরকার হলে
0xFF চিহ্ন বসে। সব সংখ্যা network ক্রমে, অর্থাৎ big-endian.চারটি type মনে রাখুন। CON (confirmable, 0): প্রাপ্তিস্বীকার চাই, না এলে আবার পাঠানো হবে। NON (non-confirmable, 1): একবার পাঠিয়ে ভুলে যাওয়া, যেমন প্রতি সেকেন্ডের এমন reading, যার একটি হারালে ক্ষতি নেই। ACK (2): একটি CON-এর প্রাপ্তিস্বীকার, প্রায়ই উত্তরও সঙ্গে নিয়ে আসে। RST (reset, 3): “এই বার্তা আমি বুঝতে পারছি না” বা “এর কোনো প্রসঙ্গ আমার কাছে নেই”.
দুটি নম্বর আলাদা কাজ করে, আর পরীক্ষায় প্রায়ই এ নিয়ে প্রশ্ন আসে। Message ID (16 bit) বার্তার স্তরের: কোন ACK কোন CON-এর, আর একই বার্তা দুবার এলে চেনা। Token (0–8 byte) অনুরোধ আর উত্তরের স্তরের: কোন উত্তর কোন অনুরোধের। সাধারণত দুটি একসাথেই মেলে, কিন্তু উত্তর দেরিতে আলাদা বার্তায় এলে বা Observe-এ শুধু token-ই মেলে।
| Code | Byte | মানে | HTTP-তে কাছাকাছি |
|---|---|---|---|
| 0.00 | 0x00 | Empty (খালি ACK, RST, ping) | — |
| 0.01 · 0.02 · 0.03 · 0.04 | 0x01–0x04 | GET · POST · PUT · DELETE | একই নামের method |
| 2.01 · 2.04 · 2.05 | 0x41 · 0x44 · 0x45 | Created · Changed · Content | 201 · 204 · 200 |
| 4.00 · 4.04 · 4.05 | 0x80 · 0x84 · 0x85 | Bad Request · Not Found · Method Not Allowed | 400 · 404 · 405 |
| 5.00 | 0xA0 | Internal Server Error | 500 |
Byte বের করার নিয়ম সরল: class × 32 + detail. যেমন 4.04 = 4 × 32 + 4 = 132 = 0x84. HTTP-র “404” লেখার তিনটি অক্ষর (3 byte) এখানে এক byte. Option-এর ক্ষেত্রেও একই মিতব্যয়িতা: প্রতিটি option-এর নম্বর লেখা হয় আগেরটির থেকে পার্থক্য (delta) হিসেবে, তাই option-গুলো নম্বরের ক্রমে সাজানো থাকে। Uri-Path-এর নম্বর 11: প্রথম Uri-Path-এর delta 11, পরেরগুলোর 0. প্রচলিত নম্বর: Observe 6, Uri-Path 11, Content-Format 12, Uri-Query 15, Block2 23, Block1 27. Content-Format-এর মান 0 মানে সাধারণ লেখা (UTF-8), 50 মানে JSON, 60 মানে CBOR.
৩ · একটি confirmable GET, byte ধরে — সত্যিকারের capture
প্রথমে reference lab-এর check চালানো হলো। Server আর client দুটিই aiocoap, শুধু 127.0.0.1-এ; UDP port চলার সময় বাছা হয় আর কোথাও ছাপা হয় না (Spec decision 40):
সত্যিকারের run — aiocoap 0.4.17 (MIT + BSD-3), Python 3.13.5
~/lab/_ref $ python -B coap_check.py
aiocoap 0.4.17 server on 127.0.0.1 (UDP port chosen at run time)
GET /coldroom/1/temp -> 2.05 Content (ACK) {"dev":"coldroom-1","seq":1,"temp_c":7.00,"alarm":"HIGH"}
PUT /coldroom/1/limit -> 2.04 Changed (ACK)
GET /coldroom/1/limit -> 2.05 Content (ACK) 8.50
GET /nothing -> 4.04 Not Found (ACK)
প্রতিটি উত্তরের পাশে “(ACK)”: অনুরোধ ছিল CON, আর উত্তর এসেছে ACK-এর ভেতরেই। এবার তারের ভেতরের byte দেখা যাক। আমার lab-এ একই resource-এর server আর client-এর মাঝে একটি ছোট UDP relay বসানো হলো, যা প্রতিটি datagram hex-এ ছাপে আর নিজের decoder দিয়ে পড়ে; aiocoap-এর নিজের decoder-এর সঙ্গেও মিলিয়ে দেখে। প্রথম অনুরোধের অংশ:
সত্যিকারের run — aiocoap 0.4.17 + UDP relay (Python 3.13.5), শুধু 127.0.0.1
~/lab/coap $ python -B coap_capture.py
GET /coldroom/1/temp
C->S 22 byte 42 01 af 2e b2 f3 b8 63 6f 6c 64 72 6f 6f 6d 01 31 04 74 65 6d 70
CON 0.01 mid=0xAF2E token=b2f3 Uri-Path=coldroom Uri-Path=1 Uri-Path=temp
S->C 66 byte 62 45 af 2e b2 f3 c1 32 ff 7b 22 64 65 76 22 3a 22 63 6f 6c 64 72
6f 6f 6d 2d 31 22 2c 22 73 65 71 22 3a 31 2c 22 74 65 6d 70 5f 63
22 3a 37 2e 30 30 2c 22 61 6c 61 72 6d 22 3a 22 48 49 47 48 22 7d
ACK 2.05 mid=0xAF2E token=b2f3 Content-Format=50 payload 57 byte
(লম্বা hex লাইনটি পড়ার সুবিধার জন্য তিন লাইনে ভাঙা হয়েছে।) আবার চালালে message ID আর token বদলায়, যেমন দ্বিতীয় run-এ 0x7B45 আর d64f: aiocoap এগুলো এলোমেলোভাবে শুরু করে, যাতে বাইরের কেউ সহজে আন্দাজ করতে না পারে। এখন 22 আর 66 byte ধাপে ধাপে পড়ুন।
| দিক | |
| Byte | |
| Bit বা মান | |
| মানে | |
| এ পর্যন্ত |
- প্রথম byte
0x42. Bit-এ 01 00 0010: version 1, type 0 মানে CON, token-এর দৈর্ঘ্য 2. Client প্রাপ্তিস্বীকার চায়। - Code
0x01. ওপরের 3 bit 000 (class 0, অর্থাৎ অনুরোধ), নিচের 5 bit 00001 (detail 1): 0.01 = GET. - Message ID
0xAF2E. দুই byte, big-endian. Server এটি ACK-এ ফেরত দেবে; একই বার্তা দুবার এলে duplicate চিনতেও কাজে লাগে। - Token
b2 f3. TKL = 2, তাই header-এর পরের 2 byte token. Client এটি মনে রাখে, উত্তর এলে মেলাবে। - তিনটি Uri-Path option.
b8: delta 11 (Uri-Path), length 8, তারপর “coldroom”.01: delta 0 (আবার Uri-Path), length 1, “1”.04: delta 0, length 4, “temp”. Payload নেই, তাই0xFFনেই। মোট 4 + 2 + 16 = 22 byte. - উত্তরের header.
0x62= 01 10 0010: type 2 মানে ACK, TKL 2.0x45= 010 00101: 2.05 Content. Message ID আর token দুটিই অনুরোধের সমান। উত্তর ACK-এর পিঠে চড়ে এসেছে: একে বলে piggybacked response. - Option আর payload.
c1 32: delta 12 (Content-Format), length 1, মান 0x32 = 50, অর্থাৎ JSON. তারপর0xFFআর 57 byte-এর JSON. মোট 6 + 2 + 1 + 57 = 66 byte. একটি datagram-এ অনুরোধ, একটিতে উত্তর।
এই একই বার্তা হাতে বানিয়ে capture-এর সঙ্গে মিলিয়ে দেখুন, আর উত্তরটিও পড়ে দেখুন। কোডটি RFC 7252-এর অংশ 3 অনুসরণ করে:
# CoAP-এর বার্তা হাতে বানানো আর পড়া (RFC 7252, অংশ 3)
def coap_get(mtype, mid, token, path):
b = bytearray([0x40 | mtype << 4 | len(token), 0x01, mid >> 8, mid & 0xFF])
b += token
last = 0
for seg in path.strip("/").split("/"): # Uri-Path = option 11
b.append((11 - last) << 4 | len(seg)) # delta, তারপর দৈর্ঘ্য
b += seg.encode()
last = 11
return bytes(b)
req = coap_get(0, 0xAF2E, bytes.fromhex("b2f3"), "/coldroom/1/temp")
real = "42 01 af 2e b2 f3 b8 63 6f 6c 64 72 6f 6f 6d 01 31 04 74 65 6d 70"
print(len(req), "byte:", req.hex(" "))
print("আসল capture-এর সঙ্গে মেলে?", req.hex(" ") == real)
resp = bytes.fromhex("6245af2eb2f3c132ff") + b'{"dev":"coldroom-1","seq":1,"temp_c":7.00,"alarm":"HIGH"}'
t = ["CON", "NON", "ACK", "RST"][resp[0] >> 4 & 3]
tkl = resp[0] & 15
code = f"{resp[1] >> 5}.{resp[1] & 31:02d}"
mid = resp[2] << 8 | resp[3]
print(f"উত্তর: {t} {code} mid=0x{mid:04X} token={resp[4:4 + tkl].hex()}")
i = 4 + tkl
opt = 0
while resp[i] != 0xFF:
opt += resp[i] >> 4
n = resp[i] & 15
print(f" option {opt}: মান {int.from_bytes(resp[i + 1:i + 1 + n], 'big')}")
i += 1 + n
print(f" payload {len(resp) - i - 1} byte:", resp[i + 1:].decode())আসল আউটপুট (ব্রাউজারের Python):
22 byte: 42 01 af 2e b2 f3 b8 63 6f 6c 64 72 6f 6f 6d 01 31 04 74 65 6d 70
আসল capture-এর সঙ্গে মেলে? True
উত্তর: ACK 2.05 mid=0xAF2E token=b2f3
option 12: মান 50
payload 57 byte: {"dev":"coldroom-1","seq":1,"temp_c":7.00,"alarm":"HIGH"}
হাতে বানানো 22 byte capture-এর সঙ্গে হুবহু মেলে (True), অর্থাৎ aiocoap-এর client ঠিক এই নিয়মেই বার্তা বানিয়েছিল। Option-এর লুপে opt += … লাইনটি লক্ষ করুন: delta যোগ করে করে আসল option নম্বর (12) পাওয়া যায়। এই কোড ছোট রাখতে 13 বা তার বেশি delta আর length-এর বাড়তি byte ধরা হয়নি; Observe-এর মতো বড় option বা লম্বা path-এ তা লাগে।
Gateway-এর firmware এই কাজ C-তে করে। নিচের ফাংশন শুধু 4 byte-এর header যাচাই করে ভাগ করে; বার্তাগুলো আমার lab-এর capture থেকে নেওয়া (প্রথমটির শুধু প্রথম 9 byte), আর শেষটি ইচ্ছে করে ভাঙা:
#include <stdio.h>
#include <stdint.h>
typedef struct { uint8_t ver, type, tkl, cls, det; uint16_t mid; } coap_hdr;
/* gateway firmware: check and split the fixed 4-byte CoAP header */
static int coap_parse(const uint8_t *b, unsigned n, coap_hdr *h) {
if (n < 4) return -1; /* too short */
h->ver = b[0] >> 6;
h->type = (b[0] >> 4) & 0x3;
h->tkl = b[0] & 0x0F;
h->cls = b[1] >> 5;
h->det = b[1] & 0x1F;
h->mid = (uint16_t)((b[2] << 8) | b[3]); /* network order */
if (h->ver != 1 || h->tkl > 8 || 4u + h->tkl > n) return -1;
return 0;
}
int main(void) {
static const char *T[] = {"CON", "NON", "ACK", "RST"};
static const uint8_t r1[] = {0x62, 0x45, 0xAF, 0x2E, 0xB2, 0xF3, 0xC1, 0x32, 0xFF};
static const uint8_t r2[] = {0x62, 0x84, 0xAF, 0x31, 0xB2, 0xF6};
static const uint8_t r3[] = {0x70, 0x00, 0x77, 0x77};
static const uint8_t r4[] = {0x89, 0x01, 0x00};
const uint8_t *m[] = {r1, r2, r3, r4};
const unsigned len[] = {sizeof r1, sizeof r2, sizeof r3, sizeof r4};
for (int i = 0; i < 4; i++) {
coap_hdr h;
if (coap_parse(m[i], len[i], &h) != 0) { printf("msg %d: rejected\n", i + 1); continue; }
printf("msg %d: %s %u.%02u mid=0x%04X tkl=%u\n", i + 1, T[h.type],
(unsigned)h.cls, (unsigned)h.det, (unsigned)h.mid, (unsigned)h.tkl);
}
return 0;
}আসল আউটপুট (Wandbox-এর compiler; আমার lab-এ Clang 22.1.8 দিয়েও একই):
msg 1: ACK 2.05 mid=0xAF2E tkl=2
msg 2: ACK 4.04 mid=0xAF31 tkl=2
msg 3: RST 0.00 mid=0x7777 tkl=0
msg 4: rejected
তিনটি আসল বার্তা ঠিকভাবে পড়া গেছে: 2.05-এর ACK, 4.04-এর ACK, আর ping-এর জবাবে আসা RST. চতুর্থটির প্রথম byte 0x89 = 10 00 1001: version 2 আর TKL 9, দুটিই অবৈধ, তাই বাদ। Network থেকে আসা byte কখনো বিশ্বাস করবেন না: দৈর্ঘ্য আর version যাচাই না করে token পড়লে buffer-এর বাইরে পড়া হবে, যা firmware-এর নিরাপত্তার পুরোনো ফাঁদ (C প্রোগ্রামিং পর্ব ৪৮). (b[2] << 8) | b[3] দিয়ে big-endian থেকে সংখ্যা বানানো হয়েছে, তাই host-এর endianness যা-ই হোক, ফল একই।
৪ · ACK না এলে — retransmission, NON, RST আর ping
UDP পৌঁছানোর কোনো নিশ্চয়তা দেয় না (Computer Networks পর্ব ২৮). তাই CoAP নিজেই একটি ছোট নিশ্চয়তার স্তর বানায়, শুধু CON বার্তার জন্য। নিয়ম RFC 7252-এর অংশ 4.2-এ: প্রথম অপেক্ষা ACK_TIMEOUT (2 s) আর ACK_TIMEOUT × ACK_RANDOM_FACTOR (2 × 1.5 = 3 s)-এর মাঝে এলোমেলো একটি সময়; ACK না এলে আবার পাঠানো আর অপেক্ষা দ্বিগুণ (exponential backoff); সর্বোচ্চ MAX_RETRANSMIT = 4 বার। aiocoap-এর কোডেও এই তিনটি মান একই। Server-এর দিকে message ID মনে রাখা হয়, যাতে একই CON দুবার এলে কাজটি দুবার না হয়, আগের ACK-ই আবার যায়।
# CON বার্তার retransmission-এর সময় (RFC 7252, অংশ 4.2 আর 4.8)
import random
ACK_TIMEOUT, ACK_RANDOM_FACTOR, MAX_RETRANSMIT = 2.0, 1.5, 4
def schedule(first_timeout):
"""প্রতিবার পাঠানোর সময় আর হাল ছাড়ার সময় (s)."""
t, timeout, sends = 0.0, first_timeout, [0.0]
for _ in range(MAX_RETRANSMIT):
t += timeout
sends.append(t)
timeout *= 2 # exponential backoff
give_up = t + timeout
return sends, give_up
for first in (ACK_TIMEOUT, ACK_TIMEOUT * ACK_RANDOM_FACTOR):
sends, give_up = schedule(first)
print(f"প্রথম timeout {first:.1f} s: পাঠানো {sends} -> হাল ছাড়া {give_up:.1f} s")
span = ACK_TIMEOUT * (2 ** MAX_RETRANSMIT - 1) * ACK_RANDOM_FACTOR
wait = ACK_TIMEOUT * (2 ** (MAX_RETRANSMIT + 1) - 1) * ACK_RANDOM_FACTOR
print(f"MAX_TRANSMIT_SPAN = {span:.0f} s, MAX_TRANSMIT_WAIT = {wait:.0f} s")
random.seed(74) # load-shedding শেষে ১০০টি যন্ত্র একসাথে চালু
firsts = [random.uniform(ACK_TIMEOUT, ACK_TIMEOUT * ACK_RANDOM_FACTOR) for _ in range(100)]
slots = [int(f / 0.05) for f in firsts] # 50 ms-এর খোপ
busiest = max(slots.count(x) for x in set(slots))
print(f"১০০টি যন্ত্র, random ছাড়া: একই মুহূর্তে (2.0 s) ১০০টি retransmission")
print(f"random সহ: {min(firsts):.2f}–{max(firsts):.2f} s জুড়ে, 50 ms-এর একটি খোপে সর্বোচ্চ {busiest}টি")আসল আউটপুট (ব্রাউজারের Python):
প্রথম timeout 2.0 s: পাঠানো [0.0, 2.0, 6.0, 14.0, 30.0] -> হাল ছাড়া 62.0 s
প্রথম timeout 3.0 s: পাঠানো [0.0, 3.0, 9.0, 21.0, 45.0] -> হাল ছাড়া 93.0 s
MAX_TRANSMIT_SPAN = 45 s, MAX_TRANSMIT_WAIT = 93 s
১০০টি যন্ত্র, random ছাড়া: একই মুহূর্তে (2.0 s) ১০০টি retransmission
random সহ: 2.00–3.00 s জুড়ে, 50 ms-এর একটি খোপে সর্বোচ্চ 10টি
প্রথম timeout সবচেয়ে বড় (3 s) হলে শেষ retransmission 45 s-এ, আর হাল ছাড়া 93 s-এ: RFC 7252-এর MAX_TRANSMIT_SPAN আর MAX_TRANSMIT_WAIT ঠিক এই দুটি সংখ্যা। অর্থাৎ একটি CON GET-এর উত্তর না পেয়ে “যন্ত্র নেই” বলতে দেড় মিনিটের বেশি লাগতে পারে; dashboard-এর timeout সেই হিসাবে রাখতে হয়। শেষ দুই লাইন random অংশের কারণ: load-shedding শেষে একশটি যন্ত্র একসাথে চালু হলে সবার retransmission একই মুহূর্তে পড়ত, আর random থাকলে তারা এক সেকেন্ড জুড়ে ছড়িয়ে যায়।
একই relay-এ একটি সাধারণ socket-এর client দিয়ে দুটি জিনিস হাতে পাঠানো হলো: একটি NON GET, আর একটি খালি CON (code 0.00), যাকে বলে “CoAP ping”:
সত্যিকারের run — aiocoap 0.4.17 server, raw socket client, শুধু 127.0.0.1 (একই coap_capture.py)
NON GET /coldroom/1/temp
C->S 22 byte 52 01 12 34 ab cd b8 63 6f 6c 64 72 6f 6f 6d 01 31 04 74 65 6d 70
NON 0.01 mid=0x1234 token=abcd Uri-Path=coldroom Uri-Path=1 Uri-Path=temp
S->C 66 byte 52 45 cf e0 ab cd c1 32 ff 7b 22 64 65 76 ... 22 7d
NON 2.05 mid=0xCFE0 token=abcd Content-Format=50 payload 57 byte
empty CON (CoAP ping)
C->S 4 byte 40 00 77 77
CON 0.00 mid=0x7777 token=-
S->C 4 byte 70 00 77 77
RST 0.00 mid=0x7777 token=-
দুটি শিক্ষা। প্রথমত, NON অনুরোধের উত্তরও NON, আর তার message ID server-এর নিজের (0xCFE0), অনুরোধের নয়; শুধু token (abcd) মেলে। ACK নেই, retransmission নেই: হারালে হারাল। দ্বিতীয়ত, খালি CON-এর জবাবে server RST পাঠিয়েছে, একই message ID-সহ। এটিই “যন্ত্রটি আছে কি?” জিজ্ঞাসার সবচেয়ে ছোট উপায়: 4 byte যায়, 4 byte আসে। একটি gateway এভাবে দেখতে পারে যন্ত্রটি জেগে আছে কি না।
আর যদি উত্তর তৈরিতে সময় লাগে, যেমন sensor থেকে নতুন reading আনতে হয়? তখন server আগে একটি খালি ACK পাঠায়, যাতে client আর retransmission না করে; পরে উত্তর আসে নিজের নতুন CON বার্তায়, server-এর নতুন message ID আর অনুরোধের token নিয়ে, আর client সেটির ACK দেয়। একে বলে separate response. aiocoap উত্তর প্রস্তুত হতে প্রায় 0.1 s-এর বেশি লাগলে এভাবে খালি ACK পাঠায় (তার EMPTY_ACK_DELAY); এই পর্বের run-এ উত্তর তৈরি হতে এর চেয়ে কম সময় লেগেছে, তাই সব উত্তর piggybacked. এখানেই message ID আর token-এর ভাগটি জরুরি হয়ে ওঠে: খালি ACK মেলে message ID-তে, পরের উত্তর মেলে শুধু token-এ।
সাবধান — CON মানে কাজ একবারই হবে, এমন নয়: ACK হারালে client আবার পাঠায়। Server message ID মনে রাখে বলে সাধারণত ঠিক থাকে, কিন্তু সেই মনে রাখা সীমিত সময়ের (EXCHANGE_LIFETIME, প্রচলিত মানে 247 s), আর server reboot হলে তা মুছে যায়। তাই PUT-এর মতো idempotent কাজ (একবার বা দুবার, ফল একই) CoAP-এ নিরাপদ; “বিক্রির সংখ্যা এক বাড়ান” ধাঁচের POST নয়।
৫ · Observe আর block-wise — প্রশ্ন না করেই খবর, আর বড় data টুকরোয়
Dashboard যদি প্রতি 10 s-এ GET পাঠায়, তাহলে প্রতিবার একটি অনুরোধ আর একটি উত্তর, তাপমাত্রা বদলাক বা না-ই বদলাক। Observe (RFC 7641, সেপ্টেম্বর ২০১৫) এর সমাধান: client একবার GET পাঠায় Observe option (নম্বর 6) মান 0 দিয়ে, মানে “আমাকে নিবন্ধন করুন”. তারপর resource বদলালেই server নিজে থেকে একটি নতুন উত্তর (notification) পাঠায়, একই token-এ। আমার lab-এ একটি observable resource /coldroom/1/t বানিয়ে দুবার তাপমাত্রা বদলানো হলো:
সত্যিকারের run — aiocoap 0.4.17, শুধু 127.0.0.1 (একই coap_capture.py)
== C: Observe on /coldroom/1/t
C->S 20 byte 42 01 af 32 b2 f7 60 58 63 6f 6c 64 72 6f 6f 6d 01 31 01 74
CON 0.01 mid=0xAF32 token=b2f7 Observe=0 Uri-Path=coldroom Uri-Path=1 Uri-Path=t
S->C 13 byte 62 45 af 32 b2 f7 60 60 ff 37 2e 30 30
ACK 2.05 mid=0xAF32 token=b2f7 Observe=0 Content-Format=0 payload 4 byte
first response 2.05 Content payload 7.00
server: temperature changes to 7.50
S->C 14 byte 42 45 cf e1 b2 f7 61 01 60 ff 37 2e 35 30
CON 2.05 mid=0xCFE1 token=b2f7 Observe=1 Content-Format=0 payload 4 byte
C->S 4 byte 60 00 cf e1
ACK 0.00 mid=0xCFE1 token=-
notification 2.05 Content payload 7.50
server: temperature changes to 8.25
S->C 14 byte 42 45 cf e2 b2 f7 61 02 60 ff 38 2e 32 35
CON 2.05 mid=0xCFE2 token=b2f7 Observe=2 Content-Format=0 payload 4 byte
C->S 4 byte 60 00 cf e2
ACK 0.00 mid=0xCFE2 token=-
notification 2.05 Content payload 8.25
| দিক | |
| বার্তা | |
| Message ID | |
| Byte | |
| Dashboard জানে |
- নিবন্ধন। সাধারণ CON GET, সঙ্গে
60: delta 6 (Observe), length 0, অর্থাৎ মান 0 = “নিবন্ধন করুন”. পরের Uri-Path-এর byte58: delta এবার 5, কারণ 6 + 5 = 11. - প্রথম উত্তর। ACK-এর পিঠে 2.05 আর বর্তমান মান 7.00. উত্তরে Observe option থাকা মানেই server নিবন্ধন নিয়েছে। Content-Format-এর
60এখানে delta 6 (6 + 6 = 12), length 0, মান 0 = সাধারণ লেখা। - প্রথম notification. তাপমাত্রা 7.50 হতেই server নিজে একটি CON পাঠাল, নিজের message ID
0xCFE1দিয়ে, কিন্তু client-এর tokenb2f7-এ। Observe-এর মান 1: পরপর বাড়ে, যাতে client পুরোনো notification চিনতে পারে। - Client-এর খালি ACK. 4 byte, code 0.00, একই message ID. Notification CON ছিল বলে client-কে প্রাপ্তিস্বীকার দিতে হলো; এই ACK না এলে server ধরে নিতে পারে client আর নেই।
- দ্বিতীয় notification. 8.25 °C, Observe = 2, message ID
0xCFE2, আবার খালি ACK. Client একবারও জিজ্ঞেস করেনি, তবু দুটি বদলই জেনেছে: মোট 20 + 13 + 18 + 18 = 69 byte.
Observe-এর একটি সূক্ষ্ম কথা: RFC 7641 প্রতিটি বদল পৌঁছানোর প্রতিশ্রুতি দেয় না। Server কিছু notification NON-এ পাঠাতে পারে, আর দ্রুত অনেক বদল হলে মাঝেরগুলো বাদ পড়তে পারে; প্রতিশ্রুতি হলো, client শেষ পর্যন্ত সর্বশেষ অবস্থা জানবে। তাপমাত্রার জন্য এটি যথেষ্ট, বিক্রির হিসাবের প্রতিটি লেনদেনের জন্য নয়। এই run-এ client নিবন্ধন বাতিল করার সময় কোনো বার্তা পাঠায়নি; RFC 7641 অনুযায়ী client Observe = 1 দিয়ে একটি GET পাঠিয়ে বা পরের notification-এ RST দিয়ে বাতিল করতে পারে।
Block-wise transfer (block-wise, RFC 7959, আগস্ট ২০১৬) আরেক সমস্যার সমাধান: বড় data. IEEE 802.15.4-এর মতো radio-র একটি frame-এ সর্বোচ্চ 127 byte ধরে, আর IP-স্তরে datagram টুকরো হলে একটি টুকরো হারালেই পুরোটা যায়। তাই CoAP নিজেই data ভাগ করে 16 থেকে 1024 byte-এর block-এ (2-এর ঘাত): উত্তরের জন্য Block2 option (23), অনুরোধের জন্য Block1 (27), প্রতিটিতে block নম্বর আর “আরও আছে” চিহ্ন। Firmware update বা একটি লম্বা config এভাবে যায়; OTA-র পুরো নকশা পর্ব ৭৫ আর ৭৭-এ।
একটি হিসাব দেখুন। Gateway cold room থেকে 1500 byte-এর একটি config পড়বে, block-এর মাপ 512 byte. Block option-এর মানে তিনটি অংশ: block নম্বর (NUM), “আরও আছে” bit (M) আর মাপের সূচক SZX, যেখানে মাপ = 2SZX + 4. 512 = 29, তাই SZX = 5, আর option-এর মান = NUM × 16 + M × 8 + SZX. প্রতিটি block একটি আলাদা GET আর তার উত্তর; একটি হারালে শুধু সেটিই আবার চাওয়া হয়।
| Block (NUM) | Byte-এর পরিসর | M | Block2-এর মান |
|---|---|---|---|
| 0 | 0–511 (512 byte) | 1 | 0 × 16 + 8 + 5 = 13 = 0x0D |
| 1 | 512–1023 (512 byte) | 1 | 16 + 8 + 5 = 29 = 0x1D |
| 2 | 1024–1499 (476 byte) | 0 | 32 + 0 + 5 = 37 = 0x25 |
শেষ block-এ M = 0, অর্থাৎ “আর নেই”. হিসাবটি Python-এ চালিয়ে মেলানো। লক্ষ করুন, প্রতিটি block-এর উত্তরে আবার CoAP header, token আর option যোগ হয়, তাই block যত ছোট, মোট বাড়তি byte তত বেশি; radio-র frame-এর মাপ দেখে block-এর মাপ বাছতে হয়।
৬ · একই resource HTTP/1.1-এ — সত্যিকারের request আর response
এবার তুলনার জন্য একই চারটি resource HTTP/1.1-এ। Server Python-এর নিজস্ব http.server, client একটি সাধারণ TCP socket, যাতে প্রতিটি byte হুবহু দেখা যায়; চারটি অনুরোধ একটি সংযোগেই গেছে (keep-alive). Port ছাপা হয় না বলে Host header-এ port নেই, যেমনটা port 80-এ হতো। প্রথম অনুরোধের অংশ:
সত্যিকারের run — Python 3.13.5 http.server (HTTP/1.1) + raw socket, শুধু 127.0.0.1
~/lab/coap $ python -B http_check.py
C->S 50 byte
| GET /coldroom/1/temp HTTP/1.1
| Host: 127.0.0.1
|
S->C 201 byte
| HTTP/1.1 200 OK
| Server: BaseHTTP/0.6 Python/3.13.5
| Date: Fri, 20 Nov 2026 02:59:07 GMT
| Content-Type: application/json
| Content-Length: 57
|
| {"dev":"coldroom-1","seq":1,"temp_c":7.00,"alarm":"HIGH"}
header 144 byte + body 57 byte
...
one TCP connection, 4 requests: bytes C->S 262, S->C 579 (TCP/IP headers not counted)
HTTP/1.1 লেখাভিত্তিক: প্রতিটি লাইন ASCII অক্ষর, শেষে দুই byte \r\n, আর একটি খালি লাইনে header শেষ। Payload একই 57 byte, কিন্তু উত্তরের header 144 byte. তার অর্ধেকই দুটি লাইন: Server (36 byte) আর Date (37 byte). HTTP-র নিয়মে (RFC 9110) ঘড়িওয়ালা origin server-কে বেশিরভাগ উত্তরে Date দিতে হয়; Server ঐচ্ছিক। আর সত্যিকারের browser বা curl অনুরোধেও আরও header জোড়ে, যেমন User-Agent আর Accept, তাই বাস্তবের অনুরোধ এই 50 byte-এর চেয়ে বড় হয়।
| Segment | |
| দিক | |
| HTTP byte | |
| TCP + IP header | |
| তারে মোট |
- SYN. HTTP-র কিছু পাঠানোর আগে TCP-র three-way handshake শুরু। প্রতিটি segment-এ কমপক্ষে 20 byte IPv4 আর 20 byte TCP header; বাস্তবে SYN-এ সাধারণত কিছু option থাকে, তাই আরও বড়।
- SYN-ACK. Server রাজি। এখনো একটি data byte-ও যায়নি, অথচ 80 byte খরচ। CoAP-এ এই ধাপই নেই: প্রথম datagram-ই অনুরোধ।
- ACK. Handshake শেষ, 120 byte. সংযোগ খোলা রাখলে (keep-alive) পরের অনুরোধগুলোতে এই খরচ আর লাগে না।
- অনুরোধ, 50 byte.
GET /coldroom/1/temp HTTP/1.1(31 byte,\r\n-সহ),Host: 127.0.0.1(17 byte), খালি লাইন (2 byte). CoAP-এর একই অনুরোধ 22 byte. - উত্তরের header, 144 byte. Status লাইন 17, Server 36, Date 37, Content-Type 32, Content-Length 20, খালি লাইন 2. সংখ্যা “200” আর “57” এখানে লেখার অক্ষর।
- Body, 57 byte. একই JSON. উত্তরটি এক segment-এ গেছে (201 + 40 = 241 byte), আর client একটি ACK পাঠায় (40 byte). HTTP-র নিজের কোনো প্রাপ্তিস্বীকার নেই; নিশ্চয়তা দেয় TCP.
- সংযোগ বন্ধ. দুই দিকের FIN আর ACK, আরও 160 byte. নতুন সংযোগে একটি GET-এ মোট 10টি segment আর 651 byte; CoAP-এ 2টি datagram আর 144 byte (পরের অংশে হিসাব).
CoAP আর HTTP-র মিল এত বেশি যে একটি proxy দুটির মাঝে অনুবাদ করতে পারে: RFC 7252 নিজেই এমন cross-proxy-র নিয়ম দেয়। বাস্তবে প্রায়ই gateway এই কাজ করে: ভেতরে ছোট যন্ত্রের সঙ্গে CoAP, বাইরে cloud-এর সঙ্গে HTTP বা MQTT (পর্ব ৭০-এর protocol translation).
৭ · Byte গুনে তুলনা — header-এর খরচ কোথায়
ছবি ৭৪.২ — তিনটি protocol-এর স্তর আর header
ওপরে application, নিচে IP; সংখ্যাগুলো প্রতিটি packet-এর ন্যূনতম header
এখন চারটি অনুরোধ পাশাপাশি রাখুন। Application স্তরের সব সংখ্যা দুটি সত্যিকারের run-এর capture থেকে:
| অনুরোধ | |
| CoAP | |
| HTTP/1.1 | |
| HTTP ÷ CoAP |
- GET temp. 57 byte-এর JSON দুই দিকেই একই, তাই পার্থক্য সবচেয়ে কম, 2.9 গুণ। Payload যত বড়, header-এর ভাগ তত ছোট।
- PUT limit. 4 byte-এর “8.50” পাঠাতে HTTP-র অনুরোধ 100 byte (Content-Type আর Content-Length-সহ), উত্তর 204-এর 119 byte. CoAP-এ 28 byte অনুরোধ, আর উত্তর শুধু 6 byte-এর ACK, 2.04 Changed.
- GET limit. 4 byte-এর মান ফেরত। CoAP-এর উত্তর 12 byte, তার একটি byte
c0(Content-Format 0, length 0). HTTP-র উত্তর 141 byte, যার 137 byte header. - GET /nothing. শূন্য payload-এ পার্থক্য সবচেয়ে বেশি: CoAP-এ 14 + 6 byte, HTTP-তে 179 byte (শেষ অনুরোধে
Connection: close-এর 19 byte-সহ). ছোট নির্দেশ আর status-এর বার্তায় header-ই প্রায় সব। - মোট। 177 বনাম 841 byte, প্রায় 4.8 গুণ। আর এখানে UDP, TCP আর IP-এর header ধরাই হয়নি; সেগুলো যোগ করলে আর নতুন সংযোগ খুললে পার্থক্য আরও বাড়ে।
তারে কী যায়, আর দিনে কতটা, তা হিসাব করুন। TCP অংশ আগের stepper-এর মডেল (ন্যূনতম header, segment-এর সংখ্যা ধরে), application byte সত্যিকারের capture:
# একই চারটি অনুরোধ: CoAP বনাম HTTP/1.1, সত্যিকারের capture-এর byte থেকে
real = { # (অনুরোধ, উত্তর) byte, application স্তর
"GET temp": ((22, 66), (50, 201)),
"PUT limit": ((28, 6), (100, 119)),
"GET limit": ((23, 12), (51, 141)),
"GET 404": ((14, 6), (61, 118)),
}
UDP_IP, TCP_IP = 8 + 20, 20 + 20 # IPv4, কোনো option ছাড়া
print(f"{'অনুরোধ':10}{'CoAP':>6}{'HTTP':>6}{'গুণ':>6}")
tc = th = 0
for name, (c, h) in real.items():
tc += sum(c); th += sum(h)
print(f"{name:10}{sum(c):6}{sum(h):6}{sum(h) / sum(c):6.1f}")
print(f"{'মোট':10}{tc:6}{th:6}{th / tc:6.1f}")
# পুরো তারে: header যোগ করে, একটি GET temp
coap = 22 + 66 + 2 * UDP_IP # CON আর ACK: ২টি datagram
http_keep = 50 + 201 + 3 * TCP_IP # খোলা সংযোগে: req, resp, ACK
http_new = 50 + 201 + 10 * TCP_IP # + handshake ৩, বন্ধ ৪
print(f"\nতারে একটি GET temp: CoAP {coap}, HTTP keep-alive {http_keep}, HTTP নতুন সংযোগ {http_new} byte")
day = 24 * 3600 // 10 # প্রতি 10 s-এ একবার
for name, b in (("CoAP", coap), ("HTTP keep-alive", http_keep), ("HTTP নতুন সংযোগ", http_new)):
print(f"দিনে {day} বার {name:16}: {day * b / 1024:7.1f} KiB")আসল আউটপুট (ব্রাউজারের Python):
অনুরোধ CoAP HTTP গুণ
GET temp 88 251 2.9
PUT limit 34 219 6.4
GET limit 35 192 5.5
GET 404 20 179 8.9
মোট 177 841 4.8
তারে একটি GET temp: CoAP 144, HTTP keep-alive 371, HTTP নতুন সংযোগ 651 byte
দিনে 8640 বার CoAP : 1215.0 KiB
দিনে 8640 বার HTTP keep-alive : 3130.3 KiB
দিনে 8640 বার HTTP নতুন সংযোগ : 5492.8 KiB
প্রতি 10 s-এ একটি reading মানে দিনে 8640 বার। CoAP-এ দিনে প্রায় 1.2 MiB, keep-alive HTTP-তে প্রায় 3.1 MiB, আর প্রতিবার নতুন সংযোগে প্রায় 5.4 MiB. Battery-চালিত যন্ত্রে প্রতিটি byte radio-র চালু থাকার সময়, তাই শক্তি (পর্ব ৬২); cellular-এ data-র পরিমাণ। দুটি সতর্কতা: TLS বা DTLS যোগ করলে প্রতিটি বার্তায় আরও কিছু byte আর শুরুতে একটি handshake যোগ হয়, যা এখানে ধরা হয়নি; আর IPv6-এর ওপর 6LoWPAN-এর মতো header সংকোচন UDP/IP-এর খরচ অনেক কমাতে পারে।
৮ · MQTT, CoAP না HTTP — কোনটি কখন, আর নিরাপত্তা
তিনটিই IoT-তে চলে, আর একই ব্যবস্থায় তিনটিই থাকতে পারে। প্রশ্ন হলো, কোন hop-এ কোনটি। পর্ব ৭০-এর চারটি সীমা (দূরত্ব, বিদ্যুৎ, data, link-এর ভরসা) এখানেও কাজে লাগে, সঙ্গে আরেকটি প্রশ্ন: যোগাযোগের ধাঁচ কী, একজন অনেককে জানায়, না একজন আরেকজনকে জিজ্ঞেস করে?
| প্রশ্ন | MQTT | CoAP | HTTP/1.1 |
|---|---|---|---|
| ধাঁচ | publish-subscribe, broker-সহ | REST অনুরোধ-উত্তর, Observe | REST অনুরোধ-উত্তর |
| Transport | TCP (সংযোগ খোলা থাকে) | UDP (TCP-রূপও আছে) | TCP |
| Header | 2 byte থেকে, binary | 4 byte থেকে, binary | লেখা, সাধারণত কয়েকশ byte |
| নিশ্চয়তা | QoS 0, 1, 2 | CON/ACK আর retransmission | TCP-র ওপর নির্ভর |
| Device-এর ভূমিকা | client, বাইরের দিকে সংযোগ | প্রায়ই server | সাধারণত client |
| নিরাপত্তা | TLS | DTLS, OSCORE | TLS (HTTPS) |
| বাজারঘরে | telemetry, retained ওজন, Last Will | gateway থেকে cold room-কে প্রশ্ন বা নির্দেশ | cloud-এর API, মালিকের report, webhook |
MQTT বাছুন যখন
একই খবর অনেকের দরকার (dashboard, phone, database), যন্ত্র NAT-এর পেছনে, আর “শেষ অবস্থা” ও “হারিয়ে গেছে” জানা জরুরি (retained, Last Will). বিস্তারিত পর্ব ৭৩-এ।
CoAP বাছুন যখন
খুব ছোট, battery-চালিত যন্ত্র; একটি নির্দিষ্ট যন্ত্রকে প্রশ্ন বা নির্দেশ; UDP-র radio network (যেমন 6LoWPAN, Thread); TCP-র সংযোগ ধরে রাখা ব্যয়বহুল।
HTTP বাছুন যখন
অপর প্রান্ত cloud-এর সেবা, browser বা অন্য কোম্পানির API; যন্ত্রে যথেষ্ট RAM আর বিদ্যুৎ আছে; অনুরোধ কম আর বিরল, যেমন দিনে একবার report.
বাজারঘরের পুরো ছবিতে তাই তিনটিই থাকে, আলাদা hop-এ। Cold room প্রতি 10 s-এ telemetry দেয়, যা gateway MQTT-তে broker-এ পাঠায়, কারণ dashboard, phone আর database সবার দরকার। Technician-এর ল্যাপটপ বা gateway নিজে cold room-এর সীমা পড়ে বা বদলায় CoAP-এ, কারণ সেটি একটি নির্দিষ্ট যন্ত্রের সঙ্গে প্রশ্ন-উত্তর। আর মাস শেষে gateway বিক্রির সারাংশ HTTPS-এ অন্য একটি সেবার API-তে পাঠায়। বাছাইয়ের সময় তিনটি প্রশ্ন করুন: কে কাকে জানায়, যন্ত্রটির কতটা RAM আর শক্তি আছে, আর অপর প্রান্ত কোন ভাষা বোঝে। আর মনে রাখুন, CoAP-এর Observe-এ প্রতিটি observer-এর খরচ যন্ত্রকেই দিতে হয়; অনেক প্রাপক হলে gateway-কে একমাত্র observer রেখে বাকিদের MQTT-তে পৌঁছানো ভালো।
নিরাপত্তা। MQTT আর HTTP সাধারণত TLS-এর ওপর চলে (তত্ত্ব Computer Networks পর্ব ৪৮-এ)। CoAP-এর UDP-তে TLS সরাসরি চলে না, তাই তার জন্য DTLS, যা datagram হারানো আর ক্রম বদল সামলায়। কিন্তু DTLS শুধু দুই প্রান্তের মাঝের একটি hop রক্ষা করে; মাঝে CoAP-HTTP proxy থাকলে proxy সব খোলা অবস্থায় দেখে। এই সমস্যার জন্য OSCORE (RFC 8613, ২০১৯): বার্তার ভেতরের অংশ নিজেই encrypt করা হয়, তাই proxy শুধু যা দরকার তা দেখে। আরেকটি ঝুঁকি UDP-র স্বভাবেই: জাল উৎস-ঠিকানার ছোট অনুরোধের বড় উত্তর অন্য কারও দিকে যেতে পারে, যাকে বলে amplification attack. তাই CoAP server-কে খোলা ইন্টারনেটে না রাখা, উত্তরের মাপ সীমিত রাখা, আর ঠিকানা যাচাইয়ের ব্যবস্থা নেওয়া জরুরি; বিস্তারিত পর্ব ৭৬-এ আর Cybersecurity পর্ব ৩৫-এ।
আরও গভীরে: CoAP-এর নকশা UDP আর ছোট radio-র জন্য হলেও, NAT আর firewall অনেক জায়গায় UDP আটকায় বা দ্রুত ভুলে যায়; তাই ২০১৮ সালে RFC 8323 CoAP-কে TCP, TLS আর WebSocket-এর ওপর চালানোর নিয়ম দেয়, যেখানে type আর message ID বাদ যায়, কারণ নিশ্চয়তা দেয় TCP. মোবাইল যন্ত্র-ব্যবস্থাপনার একটি প্রচলিত মানদণ্ড, OMA-এর LwM2M (Lightweight M2M), তার নিচে CoAP ব্যবহার করে বলে জানা যায়। আর RFC 9175 (২০২২) Echo option যোগ করেছে, যা দিয়ে server যাচাই করতে পারে যে অনুরোধ সত্যিই ওই ঠিকানা থেকে এসেছে, amplification-এর একটি প্রতিকার।
পরীক্ষা ও ইন্টারভিউতে: “CoAP-এর চার ধরনের বার্তা?” → CON, NON, ACK, RST. “CoAP-এর header কত byte?” → 4 byte, তারপর 0–8 byte token. “Message ID আর token-এর পার্থক্য?” → message ID মেলায় ACK আর duplicate, token মেলায় উত্তর আর অনুরোধ। “CoAP কেন UDP?” → handshake নেই, ছোট header, multicast, ঘুমন্ত যন্ত্রের জন্য সংযোগ ধরে রাখতে হয় না। “Observe কী?” → একবার নিবন্ধন, বদল হলে server নিজে notification পাঠায়, polling লাগে না।
৯ · AI-এর যুগে CoAP আর HTTP যাচাই
AI assistant-কে “ESP32-এর জন্য CoAP client লিখে দিন” বললে চলনসই কোড প্রায়ই আসে, কিন্তু byte-এর স্তরে ভুল লুকিয়ে থাকে। সাধারণ ভুল আর ধরার উপায়:
| AI প্রায়ই যা করে | কীভাবে ধরবেন |
|---|---|
| Option-এর নম্বর delta না লিখে সরাসরি লেখে, বা option-গুলো এলোমেলো ক্রমে বসায় | বানানো byte একটি পরিচিত library-র capture-এর সঙ্গে মেলানো, যেমন অংশ ৩-এ |
Code ভুল লেখে, যেমন 4.04-কে 0x44 (আসলে 2.04) | class × 32 + detail নিজে হিসাব; RFC 7252-এর টেবিল |
| Message ID দিয়ে উত্তর মেলায়, token উপেক্ষা করে | আলাদা উত্তর (separate response) আর Observe-এ পরীক্ষা চালানো |
| Retransmission-এর সময় বা “CoAP নিজেই TCP-র মতো নির্ভরযোগ্য” এমন দাবি | ACK_TIMEOUT, ACK_RANDOM_FACTOR, MAX_RETRANSMIT দিয়ে নিজে হিসাব (অংশ ৪) |
| Byte বা bandwidth-এর তুলনা আন্দাজে দেয় | 127.0.0.1-এ দুটি server চালিয়ে byte গোনা, অংশ ৭-এর মতো |
| DTLS ছাড়া খোলা CoAP, কোডে লেখা key, ইন্টারনেটে খোলা server | DTLS বা OSCORE, প্রতিটি যন্ত্রের আলাদা চাবি, শুধু ভেতরের network (পর্ব ৭৬) |
প্রয়োজন, সীমা আর যাচাইয়ের শর্ত প্রথমেই দিন:
AI-এর উত্তর হাতে পেলে — যাচাইয়ের চেকলিস্ট
ভাবনার প্রশ্ন
প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন, তারপর “→ উত্তর” চাপুন।
প্র ০১REST-এর ধারণা এসেছে ওয়েবের অভিজ্ঞতা থেকে, বড় server আর browser-এর জগতে। তাহলে কয়েক KiB RAM-এর একটি sensor-এ REST আনার কী দরকার ছিল, নিজস্ব ছোট binary protocol কি যথেষ্ট ছিল না?
REST নামটি আসে Roy Fielding-এর ২০০০ সালের PhD গবেষণাপত্র থেকে (University of California, Irvine). Fielding নিজে HTTP/1.1-এর নির্দিষ্টকরণের লেখকদের একজন ছিলেন, আর গবেষণাপত্রে তিনি ব্যাখ্যা করেন ওয়েব কেন এত বড় হয়েও টিকে আছে: সব জিনিসের একটি ঠিকানা, সবার জন্য একই অল্প কয়েকটি method, প্রতিটি অনুরোধ স্বয়ংসম্পূর্ণ, আর উত্তর cache করা যায়। এই নিয়মে client আর server আলাদাভাবে বদলাতে পারে, আর মাঝে proxy আর cache বসানো যায়।
২০০০-এর দশকের শেষে sensor network-এ ঠিক উল্টো ছবি ছিল: প্রতিটি নির্মাতার নিজস্ব binary protocol, নিজস্ব gateway, আর একটির সঙ্গে আরেকটির কথা বলাতে বিশেষ অনুবাদক। ছোট যন্ত্রেও IP চালানোর কাজ (6LoWPAN, RFC 4944, ২০০৭) এগোনোর পর প্রশ্ন উঠল, IP-এর ওপরে application স্তরে কী চলবে। IETF ২০১০ সালের দিকে CoRE দল গঠন করে, যার নামেই উত্তর: Constrained RESTful Environments. লক্ষ্য ছিল ওয়েবের ধাঁচ এত হালকা করা, যাতে 8-bit বা ছোট 32-bit MCU-তে চলে, অথচ HTTP-তে সরল অনুবাদ করা যায়।
লাভ কী হলো? প্রথমত, একই ধারণা: যে প্রকৌশলী ওয়েবের API বোঝেন, তিনি GET /coldroom/1/temp দেখেই বোঝেন কী হচ্ছে। দ্বিতীয়ত, proxy: gateway HTTP-র অনুরোধকে CoAP-এ অনুবাদ করে দিতে পারে, তাই cloud-এর software-কে CoAP জানতে হয় না। তৃতীয়ত, আবিষ্কার: CoRE দল /.well-known/core ঠিকানায় একটি যন্ত্রের সব resource-এর তালিকা দেওয়ার নিয়মও করেছে (RFC 6690), যাতে নতুন যন্ত্র যুক্ত হলে কী আছে জানা যায়। নিজস্ব binary protocol হয়তো দু-চার byte কম নিত, কিন্তু প্রতিটি নতুন যন্ত্রের জন্য নতুন অনুবাদক লাগত।
খরচও আছে: REST-এর ধাঁচ মূলত “জিজ্ঞেস করলে উত্তর”, আর IoT-এর অনেক কাজ “ঘটলে জানান”. সেই ফাঁক পূরণে Observe এসেছে, আর অনেক ব্যবস্থায় MQTT-র pub/sub পাশাপাশি চলে।
মূল উপলব্ধি: REST ছোট যন্ত্রে এসেছে বাইট বাঁচাতে নয়, ধারণা আর অনুবাদ সহজ করতে। CoAP সেই ধাঁচকে UDP আর ছোট header-এ নামিয়েছে, যাতে ওয়েবের অভিজ্ঞতা sensor পর্যন্ত পৌঁছায়।
প্র ০২TCP পুরোনো, পরীক্ষিত আর নির্ভরযোগ্য। তবু CoAP UDP বেছে নিয়ে নিজেই retransmission বানাল। এটি কি চাকা নতুন করে আবিষ্কার, নাকি যুক্তিসংগত সিদ্ধান্ত? পরে CoAP-কে আবার TCP-তে আনতে হলো কেন?
CoAP-এর লক্ষ্য ছিল এমন network, যেখানে IEEE 802.15.4-এর একটি radio frame-এ সর্বোচ্চ 127 byte, data-র হার 2.4 GHz-এ 250 kbit/s, packet প্রায়ই হারায়, আর যন্ত্র বেশিরভাগ সময় ঘুমায়। এমন জায়গায় TCP-র কয়েকটি স্বভাব ব্যয়বহুল। প্রথমত, handshake: একটি ছোট প্রশ্নের আগে তিনটি segment, আর বন্ধে আরও কয়েকটি; এই পর্বের হিসাবে একটি GET-এ নতুন সংযোগের HTTP-তে 10টি segment, CoAP-এ 2টি datagram. দ্বিতীয়ত, অবস্থা: প্রতিটি TCP সংযোগের জন্য buffer আর timer, যা কয়েক KiB RAM-এর MCU-তে বড় বোঝা। তৃতীয়ত, ঘুম: সংযোগ খোলা রাখতে মাঝে মাঝে জেগে উঠতে হয়। চতুর্থত, TCP-র congestion control হারানো packet-কে ভিড়ের লক্ষণ ধরে গতি কমায়, অথচ radio-তে হারানোর কারণ প্রায়ই শুধু শব্দ বা বাধা। আর UDP-তে multicast চলে: একটি বার্তায় একটি ঘরের সব আলো নিভানো যায়।
CoAP তাই TCP-র পুরো বোঝা না নিয়ে শুধু যা দরকার তা নিয়েছে: CON-এ সরল stop-and-wait, দ্বিগুণ হতে থাকা অপেক্ষা, সর্বোচ্চ ৪ বার, আর NSTART = 1, অর্থাৎ একটি server-এর সঙ্গে একসাথে একটির বেশি অপেক্ষমাণ অনুরোধ নয়। এটি TCP-র চেয়ে অনেক সরল, আর যে বার্তার নিশ্চয়তা দরকার নেই তা NON-এ যায়, কোনো খরচ ছাড়া।
কিন্তু বাস্তবের ইন্টারনেট এই পরিকল্পনা পুরোপুরি মানেনি। অনেক firewall আর NAT অচেনা UDP আটকায়, বা কিছুক্ষণ পরে UDP-র “সংযোগ” ভুলে যায়, তাই বাইরে থেকে যন্ত্রে বার্তা পৌঁছায় না। Cloud-এর সঙ্গে কথায় তাই TCP আর TLS অনেক সহজ। এই কারণে ২০১৮ সালে RFC 8323 CoAP-কে TCP, TLS আর WebSocket-এর ওপর চালানোর নিয়ম দেয়; সেখানে type আর message ID বাদ, কারণ নিশ্চয়তা দেয় TCP, কিন্তু code, token আর option একই থাকে।
অর্থাৎ সিদ্ধান্তটি network-এর ওপর নির্ভর করে: ভেতরের ছোট radio network-এ UDP, বাইরের ইন্টারনেটে প্রায়ই TCP. একই application-এর বার্তা দুই জায়গায় চলতে পারে বলে gateway-এর অনুবাদ সহজ।
মূল উপলব্ধি: CoAP-এর UDP বাছাই ছোট radio, সীমিত RAM আর ঘুমন্ত যন্ত্রের যুক্তিসংগত সিদ্ধান্ত; NAT আর firewall-এর বাস্তবতায় পরে TCP-রূপও যোগ হয়েছে। Transport বাছাই network দেখে, ফ্যাশন দেখে নয়।
প্র ০৩Observe, MQTT-র subscribe আর HTTP-র polling তিনটিই “বদল হলে জানতে চাই” সমস্যার উত্তর। তিনটি পথের মূল পার্থক্য কোথায়, আর বাজারঘরে কোনটি কোথায় মানায়?
HTTP-তে সবচেয়ে সরল পথ polling: dashboard প্রতি কয়েক সেকেন্ডে GET পাঠায়। সরল, কিন্তু অপচয়: তাপমাত্রা না বদলালেও প্রতিবার পুরো অনুরোধ আর উত্তর, আর বদল জানতে গড়ে অর্ধেক poll-এর সময় দেরি। ওয়েবে এর উন্নতি হিসেবে long polling আর পরে WebSocket এসেছে, যা browser-এর জগতে ভালো চলে, কিন্তু ছোট যন্ত্রে সংযোগ খোলা রাখার খরচ আছে।
CoAP-এর Observe (RFC 7641, ২০১৫, প্রধান লেখক Klaus Hartke) REST-এর ধাঁচ ভাঙে না: client একটি সাধারণ GET-এ Observe option যোগ করে, আর server বদল হলে একই token-এ নতুন উত্তর পাঠায়। সম্পর্কটি সরাসরি, client আর server-এর মাঝে; কোনো broker নেই। RFC-টি নিজের নিশ্চয়তা স্পষ্টভাবে সীমিত রাখে: client শেষ পর্যন্ত সর্বশেষ অবস্থা জানবে (eventual consistency), প্রতিটি মাঝের অবস্থা নয়। দ্রুত বদলালে server মাঝের notification বাদ দিতে পারে, আর client ঘুমিয়ে থাকলে সে শুধু পরের অবস্থা পাবে। এই পর্বের run-এ দুটি notification-ই CON ছিল, তাই client-কে ACK দিতে হয়েছে; ACK না দিলে server নিবন্ধন বাতিল করতে পারে।
MQTT-র subscribe-এ মাঝখানে broker: প্রকাশক জানে না কে শুনছে, আর broker একটি বার্তা অনেককে পৌঁছে দেয়, retained বার্তা দিয়ে দেরিতে আসা subscriber-কেও শেষ মান দেয়। Observe-এ প্রতিটি observer-কে server নিজে আলাদা notification পাঠায়; দশজন observer মানে দশটি বার্তা, যা ছোট যন্ত্রের পক্ষে ভারী। আবার MQTT-তে যন্ত্রকে broker-এর সঙ্গে সংযোগ খোলা রাখতে হয়।
বাজারঘরে তাই একটি মিশ্র নকশা মানানসই: cold room-এর telemetry gateway-এর মাধ্যমে MQTT-তে যায়, যাতে dashboard, phone আর database সবাই পায়; gateway নিজে cold room-কে CoAP-এ Observe করতে পারে, একমাত্র observer হিসেবে; আর মালিকের মাসিক report-এর মতো বিরল কাজ HTTP-তে। কোনো একটি পথ সব কাজে সেরা নয়।
মূল উপলব্ধি: Polling সরল কিন্তু অপচয়ী, Observe সরাসরি আর হালকা কিন্তু প্রতিটি observer-এর খরচ যন্ত্রের, MQTT broker দিয়ে অনেকের কাছে পৌঁছায়। প্রাপকের সংখ্যা আর যন্ত্রের সামর্থ্য দেখে বাছাই করুন।
প্র ০৪CoAP-এর নিরাপত্তার জন্য DTLS তো আছেই। তাহলে OSCORE-এর মতো আলাদা ব্যবস্থা কেন লাগল, আর UDP-র কোন স্বভাব CoAP server-কে অন্যের ক্ষতির হাতিয়ার বানাতে পারে?
TLS বানানো হয়েছিল TCP-র ক্রমে আসা, না হারানো byte-স্রোতের জন্য। UDP-তে datagram হারায়, ক্রম বদলায়, দুবার আসে; তাই datagram-এর জন্য DTLS তৈরি হয়, যার 1.2 সংস্করণ RFC 6347 (২০১২) আর 1.3 সংস্করণ RFC 9147 (২০২২). CoAP-এর coaps এর ওপর চলে। কিন্তু DTLS রক্ষা করে একটি “নালি”, দুই প্রান্তের মাঝে। IoT-তে প্রায়ই মাঝে একটি proxy বা gateway থাকে, যেমন HTTP থেকে CoAP অনুবাদের জন্য। তখন নিরাপত্তা দুই টুকরো: client থেকে proxy, আর proxy থেকে যন্ত্র; proxy-র ভেতরে বার্তা খোলা, আর proxy আক্রান্ত হলে সব ফাঁস।
OSCORE (Object Security for Constrained RESTful Environments, RFC 8613, জুলাই ২০১৯) উল্টো পথ নেয়: নালি নয়, বার্তার ভেতরের অংশ নিজেই রক্ষা করা। Method, বেশিরভাগ option আর payload encrypt হয়ে একটি প্যাকেটে যায়, আর বাইরে শুধু সেই অংশ খোলা থাকে যা proxy-র পথ বের করতে লাগে। তাই proxy বার্তা এগিয়ে দিতে পারে, কিন্তু পড়তে বা বদলাতে পারে না। এর জন্য দুই প্রান্তে আগে থেকে ভাগ করা চাবির ব্যবস্থা লাগে, যার কথা পর্ব ৭৫-এর provisioning-এ আসবে।
দ্বিতীয় প্রশ্নটি UDP-র স্বভাব নিয়ে। UDP-তে handshake নেই, তাই উৎস-ঠিকানা জাল করা সহজ। আক্রমণকারী শিকারের ঠিকানা উৎস হিসেবে লিখে একটি ছোট অনুরোধ পাঠালে বড় উত্তরটি যায় শিকারের কাছে। হাজারো খোলা server ব্যবহার করলে শিকারের দিকে বিশাল traffic জমে: এটিই reflection আর amplification. নিরাপত্তা গবেষকেরা ২০১৮-এর দিকে ইন্টারনেটে খোলা CoAP যন্ত্রকে এই কাজে ব্যবহারের কথা জানিয়েছিলেন বলে প্রতিবেদন আছে। RFC 7252 নিজেই এই ঝুঁকির কথা লেখে, আর পরে RFC 9175 (২০২২)-এর Echo option server-কে সুযোগ দেয় ছোট একটি প্রশ্ন করে যাচাই করতে যে অনুরোধকারী সত্যিই ওই ঠিকানায় আছে।
রক্ষার নিয়মগুলো সরল: CoAP server ইন্টারনেটে খোলা না রাখা, শুধু ভেতরের network বা gateway-এর পেছনে; যাচাই না হওয়া ঠিকানায় বড় উত্তর না পাঠানো; প্রতিটি যন্ত্রের আলাদা চাবি। এই পর্বের সব run তাই শুধু 127.0.0.1-এ।
মূল উপলব্ধি: DTLS একটি hop-এর নালি রক্ষা করে, OSCORE বার্তাকে proxy পেরিয়েও রক্ষা করে। আর UDP-র জাল ঠিকানার ঝুঁকির কারণে খোলা ইন্টারনেটে CoAP server রাখা অন্যের জন্যও বিপদ।
প্র ০৫এই পর্বের হিসাবে HTTP/1.1 CoAP-এর চেয়ে কয়েক গুণ বেশি byte নেয়। তবু বাস্তবের বহু IoT যন্ত্র HTTP-ই ব্যবহার করে। এর কারণ কী, আর HTTP নিজে কীভাবে হালকা হয়েছে?
প্রথম কারণ ছড়িয়ে থাকা অবকাঠামো। প্রায় প্রতিটি firewall HTTPS-কে যেতে দেয়, প্রতিটি cloud সেবার API HTTP-তে, আর ESP32-এর মতো Wi-Fi MCU-র SDK-তে HTTP client তৈরি থাকে। একজন একা প্রকৌশলীর জন্য “যা আগে থেকে চলে” তার মূল্য অনেক। দ্বিতীয় কারণ, অনেক যন্ত্রের সীমা আসলে byte নয়। দেয়ালের plug-এ চলা একটি Wi-Fi যন্ত্র দিনে কয়েকবার report পাঠালে কয়েকশ byte-এর header কারও ক্ষতি করে না। তৃতীয়ত, খরচের বড় অংশ প্রায়ই header নয়, TLS-এর handshake: certificate আর চাবি বিনিময়ে কয়েক KiB যেতে পারে, যা HTTP বা MQTT দুটিতেই লাগে। তাই প্রশ্নটি “HTTP খারাপ” নয়, বরং “এই যন্ত্রের সীমা কী, আর বার্তা কত ঘন ঘন”.
HTTP নিজেও বদলেছে। HTTP/1.1 প্রথম আসে RFC 2068 (১৯৯৭) আর RFC 2616 (১৯৯৯)-এ, আর ২০২২ সালে তার নিয়ম ভাগ হয়ে RFC 9110 (অর্থ) আর RFC 9112 (লেখার রূপ)-এ নতুন করে লেখা হয়। HTTP/2 (RFC 7540, ২০১৫; এখন RFC 9113) বার্তাকে binary frame-এ ভাগ করে, একটি সংযোগে অনেক অনুরোধ একসাথে চালায়, আর HPACK (RFC 7541) দিয়ে header সংকুচিত করে: একই সংযোগে বারবার আসা Server বা Content-Type-এর মতো header পরে কয়েক byte-এ নেমে আসে। HTTP/3 (RFC 9114, ২০২২) TCP ছেড়ে QUIC-এর ওপর চলে, যা নিজেই UDP-র ওপর বানানো (Computer Networks পর্ব ৩৭). মজার ব্যাপার, ওয়েবও শেষে UDP-তে নেমেছে, যে পথে CoAP অনেক আগে গিয়েছিল, যদিও কারণ আলাদা।
কিন্তু HTTP/2 আর HTTP/3 MCU-র জন্য বড়: frame-এর নিয়ম, header টেবিল আর QUIC-এর TLS 1.3 মিলে code আর RAM দুটিই অনেক লাগে। তাই ছোট যন্ত্রে বাস্তবের ছবি প্রায়ই এমন: MCU কাছের gateway-এর সঙ্গে CoAP, MQTT বা কোনো serial protocol-এ কথা বলে, আর gateway cloud-এর সঙ্গে HTTP বা MQTT-তে।
মূল উপলব্ধি: HTTP টিকে আছে অবকাঠামো, সহজলভ্যতা আর অনেক যন্ত্রের যথেষ্ট সামর্থ্যের কারণে; byte-এর খরচ সব যন্ত্রে সমান গুরুত্বপূর্ণ নয়। যেখানে byte আর শক্তিই সীমা, সেখানে CoAP বা MQTT, আর gateway দুই জগৎ জোড়ে।
অনুশীলন
প্রথমে নিজে লিখুন বা হিসাব করুন, তারপর উত্তর খুলুন। যেখানে সম্ভব, উত্তর কোর্সের lab-এ বা compiler-এ চালিয়ে যাচাই করা।
-
নকশা ও বাস্তবায়ন — firmware-এ CoAP GET বানানো: Gateway-এর firmware-এর জন্য C-তে
coap_build_get(buf, cap, mid, tok, tkl, path)লিখুন, যা একটি CON GET বানায়: path-এর প্রতিটি অংশ একটি Uri-Path option, ফেরত দেয় দৈর্ঘ্য, আর buffer ছোট হলে বা token 8 byte-এর বেশি হলে 0. mid0xAF2E, tokenb2 f3আর path/coldroom/1/tempদিলে ফল capture-এর 22 byte-এর সঙ্গে মিলতে হবে।#include <stdio.h> #include <stdint.h> #include <string.h> /* Build a confirmable CoAP GET. Returns length, or 0 if buf is too small. */ size_t coap_build_get(uint8_t *buf, size_t cap, uint16_t mid, const uint8_t *tok, uint8_t tkl, const char *path) { size_t n = 4 + tkl; if (tkl > 8 || cap < n) return 0; buf[0] = (uint8_t)(0x40 | tkl); /* Ver=1, T=CON(0), TKL */ buf[1] = 0x01; /* 0.01 GET */ buf[2] = (uint8_t)(mid >> 8); /* message ID, big-endian */ buf[3] = (uint8_t)(mid & 0xFF); memcpy(buf + 4, tok, tkl); unsigned last = 0; while (*path == '/') path++; while (*path) { size_t len = strcspn(path, "/"); if (len > 12 || n + 1 + len > cap) return 0; /* keep to 1-byte option header */ buf[n++] = (uint8_t)(((11 - last) << 4) | len); /* Uri-Path = 11, delta */ memcpy(buf + n, path, len); n += len; last = 11; path += len; while (*path == '/') path++; } return n; }আমার lab-এ Clang 22.1.8 (PyPI
ziglang0.17.1) দিয়ে compile করে চালানো হলো (সত্যিকারের run):22 byte: 42 01 af 2e b2 f3 b8 63 6f 6c 64 72 6f 6f 6d 01 31 04 74 65 6d 70, capture-এর সঙ্গে হুবহু; আর 10 byte-এর buffer-এ ফল0. একই ফাংশন Cortex-M3-এর জন্য-Os-এ compile করলে.textহলো 160 byte (memcpyআরstrcspnবাদে). সীমা জেনে রাখুন: 12-এর বেশি অক্ষরের path-অংশে বাড়তি length-byte লাগে, এই সরল রূপ তখন 0 ফেরত দেয়; আর mid ও token আসল firmware-এ এলোমেলোভাবে বাছতে হবে। -
ভুল খুঁজুন — হাতে বানানো বার্তা আর একটি নোট: একজন লিখেছেন: “GET /coldroom/1/temp-এর বার্তা:
42 01 af 2e b2 f3 b8 coldroom b1 1 b4 temp. Server না পেলে উত্তর দেবে code byte0x44, মানে 4.04. Client উত্তর মেলাবে শুধু message ID দিয়ে। আর ACK না এলে প্রতি 2 s পরপর চিরকাল আবার পাঠাবে।” অন্তত চারটি ভুল দেখান।১, option-এর delta: দ্বিতীয় আর তৃতীয় Uri-Path-এর আগে
b1আরb4মানে delta 11 আবার, অর্থাৎ option নম্বর 22 আর 33, যা Uri-Path নয়। Delta আগের option থেকে পার্থক্য: সঠিক01আর04(capture-এর মতো). ২, code:0x44= 010 00100 = 2.04 Changed. 4.04 = 4 × 32 + 4 = 132 =0x84. ৩, শুধু message ID: উত্তর আলাদা বার্তায় এলে (separate response) বা Observe-এর notification-এ message ID server-এর নিজের, অনুরোধের নয়; উত্তর মেলায় token. ৪, চিরকাল প্রতি 2 s: RFC 7252-এ অপেক্ষা প্রতিবার দ্বিগুণ, প্রথমটি 2 থেকে 3 s-এর মাঝে random, আর সর্বোচ্চ ৪ বার; হাল ছাড়ে সর্বোচ্চ 93 s-এ। নির্দিষ্ট 2 s-এ বারবার পাঠালে একসাথে চালু হওয়া অনেক যন্ত্র একই মুহূর্তে network ভরিয়ে দেবে। এর সঙ্গে একটি সঠিক কথাও আছে: প্রথম চার byte42 01 af 2eআর token নির্ভুল। -
আগে বলুন — দুটি উত্তর আর একটি সময়ের হিসাব: (ক) একটি gateway নিচের দুটি datagram পেল। প্রতিটির type, code, message ID আর token কী?
62 84 af 31 b2 f6আর70 00 77 77. (খ) একটি CON অনুরোধের প্রথম timeout এলোমেলোভাবে 2.5 s হলো, আর কোনো ACK আসে না। ACK_RANDOM_FACTOR 1.5 আর MAX_RETRANSMIT 4 ধরে কখন কখন আবার পাঠানো হবে, আর কখন হাল ছাড়বে?(ক) প্রথমটি:
0x62= 01 10 0010, ACK, TKL 2;0x84= 4.04 Not Found; message ID0xAF31; tokenb2f6. এটি lab-এরGET /nothing-এর আসল উত্তর। দ্বিতীয়টি:0x70= 01 11 0000, RST, TKL 0; code 0.00 (খালি); message ID0x7777; token নেই। এটি CoAP ping-এর আসল জবাব। দুটিই উপরের C parser-এ চালিয়ে একই ফল (সত্যিকারের run). (খ) প্রথম পাঠানো 0 s-এ, তারপর অপেক্ষা 2.5, 5, 10, 20 s: আবার পাঠানো 2.5 s, 7.5 s, 17.5 s আর 37.5 s-এ; শেষ অপেক্ষা 40 s, তাই হাল ছাড়া 77.5 s-এ (2.5 × 31). এটি 62 s (ন্যূনতম, 2 × 31) আর 93 s (সর্বোচ্চ, 3 × 31)-এর মাঝে। হিসাবটি অংশ ৪-এরschedule()ফাংশনে 2.5 দিয়ে চালিয়ে মেলানো হয়েছে। -
নকশা — তিনটি কাজ, তিনটি protocol: বাজারঘরের তিনটি কাজের জন্য MQTT, CoAP আর HTTP থেকে বাছুন আর কারণ লিখুন: (ক) smart scale-এর শেষ ওজন dashboard, phone app আর database তিন জায়গাতেই লাগবে, আর পরে চালু হওয়া phone-ও শেষ ওজন দেখবে; (খ) গুদামের gateway মাঝে মাঝে battery-চালিত একটি ছোট দরজা-sensor-কে জিজ্ঞেস করবে “দরজা খোলা?”, আর sensor-টি UDP-র একটি ছোট radio network-এ; (গ) মাস শেষে gateway একটি হিসাবরক্ষণ সেবার web API-তে বিক্রির সারাংশ পাঠাবে।
(ক) MQTT: একজন প্রকাশক, অনেক প্রাপক; broker সবাইকে পৌঁছে দেয়, আর QoS 1-এর retained বার্তা দেরিতে আসা phone-কে সঙ্গে সঙ্গে শেষ ওজন দেয় (topic
bazarghar/, Spec decision 38). CoAP-এ প্রতিটি প্রাপকের জন্য scale-কে আলাদা উত্তর বা notification দিতে হতো। (খ) CoAP: একটি নির্দিষ্ট যন্ত্রকে সরাসরি প্রশ্ন, UDP network, ছোট battery; TCP সংযোগ ধরে রাখার দরকার নেই, আর একটি CON GET-এর উত্তর এই পর্বের মাপে কয়েক ডজন byte. দরজা খোলার মুহূর্তেই জানতে চাইলে gateway Observe করতে পারে। (গ) HTTP (HTTPS): অপর প্রান্ত একটি web সেবা, যার API HTTP-তে; মাসে একবার, gateway-এর RAM আর বিদ্যুৎ যথেষ্ট, তাই header-এর খরচ নগণ্য। লক্ষ করুন, তিনটি একই ব্যবস্থায় থাকতে পারে, আর gateway তাদের মাঝে অনুবাদক।scale/ 1/ weight
নিজেকে যাচাই করুন
ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।
ক্রমএকটি CoAP CON GET অনুরোধ, যার উত্তর ACK-এর সঙ্গেই আসে, তার ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)
- Client একটি নতুন message ID আর token বাছে
- Client Uri-Path option-সহ CON GET পাঠায় আর retransmission-এর timer চালু করে
- Server message ID দেখে duplicate কি না যাচাই করে আর resource খোঁজে
- Server একই message ID আর token-সহ ACK-এ 2.05 আর payload পাঠায়
- Client message ID মিলিয়ে timer থামায় আর token মিলিয়ে উত্তরটি অনুরোধের কাছে পৌঁছায়
RFC 7252-এর CoAP বার্তার নির্দিষ্ট header (token আর option বাদে) কত byte?
- 2 byte
- 4 byte
- 8 byte
- 20 byte
একটি CoAP উত্তরের code byte 0x84. এর মানে কী?
- 2.04 Changed
- 8.4, একটি অজানা code
- 4.04 Not Found
- HTTP status 132
একটি CoAP server অনুরোধের উত্তর তখনই দিতে পারছে না, তাই আগে একটি খালি ACK পাঠাল, আর কয়েক সেকেন্ড পরে নতুন message ID-সহ একটি CON-এ উত্তর পাঠাল। Client কী দেখে বুঝবে উত্তরটি কোন অনুরোধের?
- Message ID
- Server-এর IP ঠিকানা আর port
- Content-Format option
- Token
CoAP-এ ACK_TIMEOUT = 2 s, ACK_RANDOM_FACTOR = 1.5 আর MAX_RETRANSMIT = 4. একটি CON বার্তার প্রথম পাঠানো থেকে কোনো ACK না পেয়ে হাল ছাড়া পর্যন্ত সর্বোচ্চ কত সময় লাগতে পারে?
- 93 s
- 45 s
- 62 s
- 8 s
একটি তাপমাত্রার resource-এ client CoAP Observe দিয়ে নিবন্ধন করেছে। তাপমাত্রা খুব দ্রুত পাঁচবার বদলাল। RFC 7641 অনুযায়ী client কী নিশ্চিতভাবে পাবে?
- পাঁচটি বদলের প্রতিটি, ক্রমে
- কিছুই না, যতক্ষণ না client আবার GET পাঠায়
- শেষ পর্যন্ত সর্বশেষ মান, মাঝের কিছু বাদ পড়তে পারে
- শুধু নিবন্ধনের সময়ের প্রথম মান
একটি সত্যিকারের পরীক্ষায় একই JSON (57 byte) পড়ার অনুরোধ CoAP-এ অনুরোধ 22 + উত্তর 66 byte, আর HTTP/1.1-এ অনুরোধ 50 + উত্তর 201 byte নিল। HTTP-র বাড়তি byte-এর প্রধান কারণ কোনটি?
- HTTP-তে JSON বড় করে লেখা হয়
- TCP-র header এই সংখ্যার ভেতরে গোনা
- HTTP payload-কে gzip করে
- HTTP/1.1-এর লেখাভিত্তিক header (status লাইন, Server, Date, Content-Type ইত্যাদি)
শব্দকোষ
লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:
মনে রাখুন
- REST দুই ওজনে: resource-এর ঠিকানা আর GET, PUT, POST, DELETE; HTTP লেখার header আর TCP-তে, CoAP 4 byte-এর binary header আর UDP-তে।
- CoAP-এর বার্তা: Ver, type, TKL | code (class × 32 + detail) | message ID, তারপর token, delta-ধরে option,
0xFFআর payload. GET /coldroom/1/temp = 22 byte, তার 2.05 উত্তর 66 byte. - নিশ্চয়তা: CON-এর ACK না এলে 2–3 s থেকে দ্বিগুণ হতে থাকা অপেক্ষায় সর্বোচ্চ ৪ বার, হাল ছাড়া সর্বোচ্চ 93 s-এ; message ID মেলায় ACK, token মেলায় উত্তর; NON-এ কোনো নিশ্চয়তা নেই।
- Observe আর block-wise: একবার নিবন্ধন, বদলে server নিজে জানায় (শেষ অবস্থা নিশ্চিত, প্রতিটি নয়); বড় data 16–1024 byte-এর block-এ।
- বাছাই: চারটি অনুরোধে CoAP 177 বনাম HTTP 841 byte; অনেক প্রাপকে MQTT, ছোট যন্ত্রকে সরাসরি প্রশ্নে CoAP, cloud আর web-এ HTTP; নিরাপত্তায় TLS, DTLS বা OSCORE.
আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ
- মাইক্রোপ্রসেসর, এমবেডেড সিস্টেম ও IoT · কোর্স হোম৮৫টি পর্বপুরো কোর্সের মানচিত্র আর বাজারঘরের দুটি device-এর পথ।
- পর্ব ৭০ · IoT architectureআগের ভিত্তিপ্রতিটি hop-এর protocol বাছাই আর gateway-এর অনুবাদের কাজ।
- Computer Networks পর্ব ৩৬ · HTTPপাশের ট্র্যাকRequest, response, header আর REST, network-এর দৃষ্টিতে।
- Computer Networks পর্ব ২৮ · UDPপাশের ট্র্যাকCoAP যার ওপর বসে: datagram, 8 byte header আর নিশ্চয়তা না থাকা।
- System Design পর্ব ০৮ · REST API নকশাপাশের ট্র্যাকResource, status code আর idempotency, বড় back end-এর দৃষ্টিতে।