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

এমবেডেড কাজের সংখ্যা — binary, hex, BCD, two's complement আর fixed-point

Numbers for Embedded Work — Binary, Hex, BCD, Two's Complement and Fixed-Point

Taught in Bangla, this lesson covers the number skills firmware needs: reading register bits in hex, two's complement and sign extension of a negative sensor temperature, and carry versus overflow on the 8085, 8086 and Cortex-M. In-page Python converts bases, computes flags and drives a BCD 7-segment display. It explains endianness against MQTT and sensor byte order, and shows fixed-point C compiled with Clang, where a 16-bit int on AVR gives a wrong price and Cortex-M the right one.

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

  • Datasheet আর debugger-এর hex মান দেখে কোন বিট কী বলছে, তা দ্রুত পড়া
  • Sensor-এর signed data ঠিকমতো sign extend করা, আর ভুল করলে কী হয় তা চেনা
  • 8085, 8086 আর Cortex-M-এ যোগ-বিয়োগের পরে flag দেখে carry আর overflow আলাদা করা
  • BCD দিয়ে দাম যোগ করা আর 7-segment display-এ দেখানো, DAA-র কাজ ধাপে ধাপে
  • Memory-তে byte-এর ক্রম, network আর sensor-এর ক্রমের সঙ্গে মেলানো, আর fixed-point-এ নিরাপদ হিসাবের প্রথম নিয়ম

১ · আবার সংখ্যা কেন — register, datasheet আর display-এর ভাষা

সংখ্যা পদ্ধতির তত্ত্ব আপনি হয়তো আগেই পড়েছেন। Computer Architecture পর্ব ০৪ binary, octal আর hex-এর রূপান্তর শেখায়, পর্ব ০৫ two's complement আর overflow-এর গণিত, আর পর্ব ০৬ endianness আর বিটের কারসাজি। এক লাইনে মনে করিয়ে দিই: binary-তে প্রতিটি ঘরের ওজন দ্বিগুণ হয় (১, ২, ৪, ৮ …), আর চারটি বিট মিলে একটি hexadecimal অঙ্ক। এই পর্বে সেই তত্ত্ব আবার শেখানো হবে না। এখানে প্রশ্ন একটাই: একজন firmware লেখকের টেবিলে সংখ্যাগুলো আসলে কোন চেহারায় আসে, আর কোথায় ভুল হয়?

এমবেডেড কাজে সংখ্যা চার জায়গা থেকে আসে। এক, datasheet: সেখানে প্রতিটি register-এর ঠিকানা আর reset মান hex-এ লেখা। দুই, debugger আর simulator: register আর memory hex-এ দেখায়। তিন, sensor আর bus: I2C বা SPI দিয়ে আসা byte, যেগুলো কখনো signed, কখনো ভগ্নাংশ, কখনো বড় byte আগে। চার, মানুষের জন্য display: দোকানের ক্রেতা দাম দেখতে চান দশমিকে, “81.88”, hex-এ নয়। এই চার জায়গার সংখ্যা ঠিকমতো মেলাতে না পারলে firmware ঠিক কম্পাইল হয়, চলেও, কিন্তু ভুল উত্তর দেয়।

উপমা — কাঁচাবাজারের দাঁড়িপাল্লা আর খাতা: বাজারঘরের দোকানদার ওজন দেখেন দাঁড়িপাল্লায় (sensor-এর কাঁচা সংখ্যা), হিসাব লেখেন খাতায় পয়সা ধরে (firmware-এর integer), আর ক্রেতাকে বলেন “একাশি টাকা আটাশি পয়সা” (display). তিনটিই একই জিনিসের তিন রূপ। ভুল হয় রূপ বদলানোর সময়: পাল্লার কাঁটা উল্টো দিকে গেলে, খাতায় ঘর কম পড়লে, বা টাকা আর পয়সার জায়গা অদলবদল হলে। এই পর্বের প্রতিটি অংশ এমন একটি রূপ বদলের জায়গা।

লেখার নিয়ম শুরুতেই বলে রাখি। 8085 আর 8086-এর কোড আর memory-র ঠিকানায় Intel-এর ধরন: শেষে H, যেমন 2050H, 0FFH. Microcontroller, C আর ARM-এর জায়গায় C-এর ধরন: শুরুতে 0x, যেমন 0x40010800. এই পর্বে দুটোই আসবে, কারণ দুই জগতের সেতু এখানেই। Binary টেবিলে চারটি বিট করে ফাঁক রেখে লেখা হবে, যেমন 1111 1111 1000 0000.

নিচের ব্লকটি একটি ছোট converter. চারটি সংখ্যা নিয়ে প্রতিটির hex, binary, BCD রূপ আর signed অর্থ ছাপে। সংখ্যাগুলো এই কোর্সের: 37, 200, স্মার্ট স্কেলের ADC-র 1380 count (1400 g-এ), আর cold room sensor-এর 0xFF80.

# এক সংখ্যা, অনেক রূপ: দশমিক, hex, binary, BCD আর two's complement-এর অর্থ
def bits4(v, bits):                    # binary, চার বিট করে ফাঁক
    s = format(v, f"0{bits}b")
    return " ".join(s[i:i + 4] for i in range(0, bits, 4))

def bcd(n):                            # প্রতিটি দশমিক অঙ্ক আলাদা 4 বিটে
    return " ".join(format(int(d), "04b") for d in str(n))

def signed(v, bits):                   # একই বিট, signed হিসেবে পড়লে
    return v - (1 << bits) if v >> (bits - 1) else v

for n, bits in [(37, 8), (200, 8), (1380, 16), (0xFF80, 16)]:
    print(f"{n:>5} = {n:0{bits // 4}X}H = {bits4(n, bits)}")
    print(f"      BCD: {bcd(n)} | signed অর্থ: {signed(n, bits)}")

print(int("1FFC", 16), int("0b0110_0000", 2), hex(8188), bin(0x60))

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

   37 = 25H = 0010 0101
      BCD: 0011 0111 | signed অর্থ: 37
  200 = C8H = 1100 1000
      BCD: 0010 0000 0000 | signed অর্থ: -56
 1380 = 0564H = 0000 0101 0110 0100
      BCD: 0001 0011 1000 0000 | signed অর্থ: 1380
65408 = FF80H = 1111 1111 1000 0000
      BCD: 0110 0101 0100 0000 1000 | signed অর্থ: -128
8188 96 0x1ffc 0b1100000

তিনটি জিনিস খেয়াল করুন। প্রথমত, 37-এর binary 0010 0101 আর BCD 0011 0111 আলাদা: BCD প্রতিটি দশমিক অঙ্ককে (৩ আর ৭) আলাদা nibble-এ রাখে। দ্বিতীয়ত, 200 এক byte-এ আঁটে, কিন্তু signed byte হিসেবে পড়লে −56; কোন অর্থ ঠিক, তা বিট বলে না, বলে আপনার type. তৃতীয়ত, 0xFF80 দশমিকে 65408, অথচ এর BCD রূপে পাঁচটি অঙ্ক লাগে, কারণ BCD দশমিক অঙ্ক গোনে, বিট নয়। শেষ লাইনে Python-এর নিজের রূপান্তর: int(…, 16), hex(), bin(); debugger-এর মান দ্রুত মেলাতে এগুলোই যথেষ্ট।

২ · Binary আর hex — register পড়া মানে বিট গোনা

বাজারঘর board (কোর্সের virtual board, আসল Cortex-M chip-এর আদলে বানানো, বাস্তবে এমন কোনো product নেই) GPIOA-এর output register ODR রাখে 0x40010800 + 0x0C ঠিকানায়, অর্থাৎ 0x4001080C-এ (reference lab-এর README, memory map). এই ঠিকানায় পড়া বা লেখা মানে আসলে pin-এর অবস্থা পড়া বা বদলানো; একে বলে memory-mapped I/O. PA5-এ সবুজ LED, PA6-এ alarm. Debugger যদি দেখায় ODR = 0x00000060, তাহলে কী জ্বলছে?

উত্তর পেতে পুরো সংখ্যাকে দশমিকে নেওয়ার দরকার নেই। প্রতিটি hex অঙ্ক একটি nibble, তাই ডান দিক থেকে অঙ্ক ধরে ধরে পড়ুন: শেষ অঙ্ক 0 মানে বিট ৩–০ সব বন্ধ; তার আগের অঙ্ক 6 = 0110, যা বিট ৭–৪-এর ঘর, অর্থাৎ বিট ৬ আর বিট ৫ চালু। দুটোই জ্বলছে: LED আর alarm. বিট গোনা শুরু হয় ডান দিকের LSB থেকে, বিট ০; সবচেয়ে বাঁয়ের বিট MSB.

HexবিটHexবিটকাজের মনে রাখার উপায়
1000181000একটি বিট চালু: ঘরের সবচেয়ে ছোট বা বড় বিট
20010C1100C = ওপরের দুই বিট
40100E1110E = শুধু বিট ০ বন্ধ
30011F1111F = চারটিই চালু; 0xFF = এক byte-এর সব বিট
60110A1010A, 5 একটি পরপর একটি: পরীক্ষার pattern

একটি বিটের মান বের করতে bitmask লাগে: বিট n-এর জন্য 1u << n. PA5-এর mask 1u << 5 = 0x20, PA6-এর 0x40, দুটো মিলে 0x60. C-তে set, clear আর toggle-এর পুরো কৌশল C কোর্সের পর্ব ০৯-এ আছে, আর register-এর ওপর সেগুলোর ব্যবহার এই কোর্সের পর্ব ৩৫ (Register-এর bit manipulation)-এ। এখানে শুধু পড়ার অভ্যাস।

আরেকটি বাস্তব উদাহরণ। ARM-এর SysTick timer-এর CALIB register বাজারঘর board-এ পড়লে আসে 0x4001387F (Spec decision 22). ARMv7-M Architecture Reference Manual অনুযায়ী এই register-এর বিট ৩১ NOREF, বিট ৩০ SKEW, আর বিট ২৩–০ TENMS, অর্থাৎ ১০ ms-এর জন্য কত count. ভেঙে পড়ি: প্রথম hex অঙ্ক 4 = 0100, তাই বিট ৩১ = 0 আর বিট ৩০ = 1. নিচের ছয় অঙ্ক 01387F = 79999. সত্যিই, 8 MHz clock-এ ১০ ms = 80,000টি cycle, আর timer গোনে LOAD + 1 পর্যন্ত, তাই 79,999. একই হিসাবে blink-এর ১ ms-এর LOAD 7999 = 0x1F3F. Datasheet-এর একটি hex মান এভাবে তিনটি আলাদা তথ্য বহন করে।

মূল ধারণা

Register-এর মান কখনো “একটি সংখ্যা” নয়, পাশাপাশি বসানো কয়েকটি field. পড়ার নিয়ম: (১) hex-কে nibble-এ ভাঙুন, (২) datasheet-এর bit-field টেবিল থেকে প্রতিটি field-এর সীমানা নিন, (৩) প্রতিটি field-কে নিজের অর্থে পড়ুন: কোনোটি flag, কোনোটি unsigned count, কোনোটি signed মান।

৩ · Two's complement আর sign extension — sensor-এর ঋণাত্মক তাপমাত্রা

বাজারঘরের cold room-এ মাছ আর সবজি থাকে ০ থেকে ৮ °C-এর মধ্যে, কিন্তু compressor বেশি চললে তাপমাত্রা শূন্যের নিচে নামতে পারে। তাই sensor-কে ঋণাত্মক মানও পাঠাতে হয়। প্রায় সব আধুনিক sensor আর CPU ঋণাত্মক সংখ্যা রাখে two's complement-এ: n বিটের MSB-এর ওজন −2n−1, বাকিগুলোর ধনাত্মক। ৮ বিটে পরিসর −128 থেকে +127, ১৬ বিটে −32768 থেকে +32767. বিস্তারিত গণিত Computer Architecture পর্ব ০৫-এ।

Cold room-এর sensor TMP102-এর মতো (reference README, “বাজারঘর devices”): ১২ বিটের two's complement সংখ্যা, প্রতি ধাপ 0.0625 °C (১/১৬ °C), ১৬ বিটের word-এর বাঁ দিকে বসানো। তার মানে নিচের চারটি বিট সবসময় 0. নিচের ছবিতে −0.50 °C-এর word 0xFF80, বিট ধরে ধরে।

ছবি ৫.১ — Cold room sensor-এর ১৬ বিটের word

১২ বিটের two's complement, বাঁয়ে বসানো; উদাহরণ −0.50 °C = 0xFF80

Cold room sensor-এর word-এর বিট বিন্যাস 1511730 11111111 10000000 FF80 পূর্ণ অংশ (চিহ্নসহ)ভগ্নাংশসবসময় 0 বিট ১৫: ওজন −128 °C (চিহ্ন) বিট ৮: ওজন 1 °C বিট ৪: ওজন 0.0625 °C (১/১৬) −128 + 64 + 32 + … + 1 + 0.5 = −0.50 °C word ÷ 256 = °C; (word >> 4) ÷ 16 = °C
ছবি ৫.১ — বিট ১৫ থেকে ৮ পর্যন্ত সব 1, আর বিট ৭ = 1. চিহ্ন-বিটের ওজন −128, তার পরের সাতটির যোগফল +127, বিট ৭-এর ওজন 0.5: মোট −128 + 127 + 0.5 = −0.5 °C. পুরো word-কে signed ১৬ বিট ধরে ২৫৬ দিয়ে ভাগ করলেও একই উত্তর, কারণ word-এর সবচেয়ে ছোট ঘর (বিট ০) আসলে ১/২৫৬ °C-এর ঘর।

Firmware-এ ১২ বিটের মানটি বের করতে word-কে ৪ ঘর ডানে সরাতে হয়। কিন্তু কোন shift? এখানেই প্রথম বড় ফাঁদ। Logical shift বাঁয়ে 0 ঢোকায়, তাই ঋণাত্মক মান হঠাৎ বিশাল ধনাত্মক হয়ে যায়। Arithmetic shift বাঁয়ে চিহ্ন-বিটের কপি ঢোকায়। আর ১৬ বিটের signed মানকে ৩২ বিটের register-এ তোলার সময় বাঁয়ের ১৬টি নতুন বিটে চিহ্নের কপি বসানোর নাম sign extension. বাজারঘরের coldroom.c লেখে (int32_t)(int16_t)I2C1->DATA >> 4: আগে signed ১৬ বিট, তারপর shift. সত্যিকারের Clang এই লাইন থেকে কী বানায়, দেখুন (সত্যিকারের run, ziglang 0.17.1-এর Clang 22.1.8, --target=thumbv7m-none-eabi -mcpu=cortex-m3 -O2 -fno-sanitize=undefined, directive বাদ; ফাইল conv.c):

temp_t16:                    @ (int32_t)(int16_t)raw >> 4
	sxth	r0, r0
	asrs	r0, r0, #4
	bx	lr
temp_t16_bad:                @ raw >> 4  (raw: uint16_t)
	lsrs	r0, r0, #4
	bx	lr
load_s8:                     @ return *p;  (const int8_t *p)
	ldrsb.w	r0, [r0]
	bx	lr
load_u8:                     @ return *p;  (const uint8_t *p)
	ldrb	r0, [r0]
	bx	lr

sxth (sign extend halfword) চিহ্ন ছড়ায়, asrs চিহ্ন রেখে সরায়। ভুল সংস্করণে শুধু lsrs, অর্থাৎ বাঁয়ে 0. নিচের দুটি load-এর পার্থক্যও একই কারণে: int8_t পড়তে ldrsb (sign extend করে), uint8_t পড়তে ldrb (বাঁয়ে 0). Compiler বিটের অর্থ জানে শুধু আপনার লেখা type থেকে। নিচের stepper-এ একটি পড়া ধাপে ধাপে চলে।

1raw = I2C1->DATA;  // 2 byte2sxth r0, r0         // int163asrs r0, r0, #4     // ÷164centi = t16*25/4;   // 1/100 °C5lsrs r0, r0, #4     // ভুল পথ
Register আর অর্থ
r0
দশমিক
°C
  1. Bus থেকে দুটি byte. TMP102-এর মতো sensor তাপমাত্রার register পড়লে আগে বড় byte 0xFF, পরে ছোট byte 0x80 পাঠায়। বাজারঘর board-এর I2C মডেল register-স্তরের: একটি START-এ দুটি byte পড়ে DATA-তে রাখে (Spec decision 26).
  2. Register-এ কাঁচা মান। r0 = 0x0000FF80. ৩২ বিটের register-এ ১৬ বিটের uint16_t বসেছে বাঁয়ে 0 দিয়ে, তাই unsigned অর্থে 65408. এখনো এটি তাপমাত্রা নয়।
  3. sxth: sign extension. বিট ১৫ = 1, তাই বাঁয়ের ১৬টি বিটে 1 বসল: 0xFFFFFF80 = −128. ছবি ৫.১-এর মতো এই সংখ্যাকে ২৫৬ দিয়ে ভাগ করলেই −0.50 °C.
  4. asrs: arithmetic shift. চার ঘর ডানে, বাঁয়ে চিহ্নের কপি: 0xFFFFFFF8 = −8. এটি ১/১৬ °C-এর একক (t16): −8 × 0.0625 = −0.50 °C. Alarm-এর সীমাও এই এককে: ৮.০০ °C = 128.
  5. প্রদর্শনের জন্য শতাংশ। −8 × 25 ÷ 4 = −50, অর্থাৎ −0.50. বাজারঘর board-এ সত্যিকারের run এই লাইনই ছাপে: sensor raw=0xFF80 t16=-8 T=-0.50 C (নিচে পুরো আউটপুট)।
  6. ভুল পথ: lsrs. Type uint16_t রেখে সরালে বাঁয়ে 0 ঢোকে: 0x00000FF8 = 4088, যা 255.50 °C. ৮.০০-এর ওপরে, তাই firmware তিনবার পড়েই HIGH alarm বাজাত, অথচ ঘর আসলে ঠান্ডা।

সত্যিকারের run, বাজারঘর board-এ। একটি ছোট firmware (numsys.c, লেখকের lab-এ, reference-এর coldroom.c-এর পড়ার লাইন হুবহু) script দিয়ে আগে −0.50 °C, ১ ms পরে −25.00 °C দেয় (python -B board.py run numsys.elf --script numsys.json, Clang 22.1.8, Unicorn 2.1.4):

[     0.3756 ms] UART: sensor raw=0xFF80 t16=-8 T=-0.50 C
[     1.0000 ms] > cold-room temperature: -25.00 C
[     2.6811 ms] UART: sensor raw=0xE700 t16=-400 T=-25.00 C

README-র টেবিলের দুটি মানই মিলল: −0.50 °C = 0xFF80, −25 °C = 0xE700. ধনাত্মক দিকে ৪.০০ °C = 0x0400: t16 = 64, শতাংশে 400. (এই পর্বের সত্যিকারের run-এর tool আর licence: ziglang 0.17.1, MIT, যার Clang/LLVM অংশ Apache-2.0 with LLVM exception; Unicorn 2.1.4, Python binding BSD আর engine GPLv2; NASM 3.02, BSD-2-Clause; 8085 simulator কোর্সের নিজের, pure Python.)

C-র একটি সূক্ষ্ম কথা: (int16_t)0xFF80-এর মতো সীমার বাইরের মানকে signed type-এ রূপান্তর, আর ঋণাত্মক সংখ্যার ডান shift, দুটোই C standard-এ implementation-defined: compiler নিজের নথিতে নিয়ম লিখে রাখে। GCC আর Clang দুটোই modulo রূপান্তর আর arithmetic shift করে বলে নথিতে লেখে, আর C23 থেকে signed সংখ্যার রূপ two's complement হওয়া বাধ্যতামূলক। তবু ভালো অভ্যাস: কোন compiler-এর কোন নিয়মে ভরসা করছেন, তা কোডের মন্তব্যে লিখে রাখা। আরেকটি পার্থক্য মনে রাখুন: ঋণাত্মক সংখ্যায় C-র ভাগ শূন্যের দিকে গোল করে, arithmetic shift নিচের দিকে (−7 ÷ 2 = −3, কিন্তু −7 >> 1 = −4). এই sensor-এর word-এর নিচের চার বিট সবসময় 0, তাই এখানে ১৬ দিয়ে ভাগ আর ৪ ঘর shift একই ফল দেয়।

৪ · Carry বনাম overflow — তিন CPU-র flag

একটি যোগের পরে CPU কয়েকটি এক-বিটের খবর রেখে দেয়, যাকে বলে status flags. Assembly-তে শর্তযুক্ত লাফ (JC, JZ) এগুলো দেখেই সিদ্ধান্ত নেয়। দুটি flag নিয়ে সবচেয়ে বেশি গোলমাল হয়। Carry flag বলে, unsigned ফল কি বিটে আঁটল? Overflow flag বলে, signed ফল কি আঁটল? একই যোগের পরে উত্তর দুটো আলাদা হতে পারে, কারণ adder জানে না আপনি বিটগুলোকে কোন অর্থে পড়ছেন। নিয়মটি সহজ: দুটি সংখ্যার চিহ্ন এক, অথচ ফলের চিহ্ন আলাদা হলে overflow. সমতুল্য রূপ: MSB-তে ঢোকা carry আর MSB থেকে বেরোনো carry আলাদা হলে overflow. ALU-র ভেতরে এগুলো কীভাবে তৈরি হয়, তা Computer Architecture পর্ব ২০-এ।

এখন তিনটি CPU-র flag register পাশাপাশি। খেয়াল করুন, 8085-এর flag register-এ overflow-এর কোনো ঘরই নেই।

ছবি ৫.২ — তিনটি CPU-র flag register

হলুদ = carry, লাল = overflow; ধূসর = অব্যবহৃত বা অন্য কাজের ঘর

8085, 8086 আর Cortex-M-এর flag register 8085 · F (৮ বিট) 8086 · FLAGS (নিচের ১২ বিট) Cortex-M · APSR (ওপরের ৫ বিট) SZ0AC0P0CY 76543210 OFDFIFTFSFZFAFPFCF 117420 NZCVQ বাকি বিট 3130292827 8085-এ overflow-এর ঘর নেই
ছবি ৫.২ — 8085-এর বিট ৫, ৩, ১ এই কোর্সের simulator-এ সবসময় 0 (Spec decision 3; আসল chip-এ সেখানে নথিভুক্ত নয় এমন বিট থাকে, নিচের “আরও গভীরে” দেখুন)। 8086-এর বিন্যাস Intel-এর 8086 manual অনুযায়ী, Cortex-M-এর APSR ARMv7-M Architecture Reference Manual অনুযায়ী। 8086-এর sign flag-এর নাম SF, ARM-এ N (negative); কাজ একই, ফলের MSB-র কপি।

8085-এর পাঁচটি flag: S (ফলের বিট ৭), Z (ফল শূন্য), AC (বিট ৩ থেকে বিট ৪-এ carry, শুধু BCD-র জন্য), P (ফলে 1-এর সংখ্যা জোড় হলে 1), আর CY. এগুলোর নিয়ম কোর্সের simulator-এ Spec decision 4: যোগে CY = বিট ৭ থেকে বেরোনো carry; বিয়োগ হিসাব হয় A + (NOT operand) + 1 হিসেবে, আর CY = 1 মানে borrow হয়েছে। নিচের ব্লক একই নিয়মে চারটি হিসাব করে, সঙ্গে একটি বাড়তি V, যা 8085 রাখে না।

# 8-বিট ADD/SUB: 8085-এর পাঁচটি flag (Spec decision 4) আর একটি বাড়তি V
def alu8(a, b, sub=False):
    cin = 0
    if sub:                                  # A - B = A + (NOT B) + 1
        b, cin = (~b) & 0xFF, 1
    total = a + b + cin
    r = total & 0xFF
    cy = (total >> 8) ^ (1 if sub else 0)    # বিয়োগে CY = borrow
    ac = ((a & 0xF) + (b & 0xF) + cin) >> 4  # bit 3 থেকে bit 4-এ carry
    p = 1 if bin(r).count("1") % 2 == 0 else 0
    v = 1 if (a ^ r) & (b ^ r) & 0x80 else 0 # দুই operand-এর চিহ্ন এক, ফলের আলাদা
    return r, f"S={r >> 7} Z={int(r == 0)} AC={ac} P={p} CY={cy} | V={v}"

def sv(x):                                   # signed অর্থ
    return x - 256 if x & 0x80 else x

for a, b, sub in [(0x7F, 0x01, 0), (0xFF, 0x01, 0), (0x80, 0x80, 0), (0x05, 0x07, 1)]:
    r, fl = alu8(a, b, sub)
    op = "-" if sub else "+"
    print(f"{a:02X}H {op} {b:02X}H = {r:02X}H  {fl}")
    print(f"   unsigned: {a} {op} {b} -> {r}   signed: {sv(a)} {op} {sv(b)} -> {sv(r)}")

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

7FH + 01H = 80H  S=1 Z=0 AC=1 P=0 CY=0 | V=1
   unsigned: 127 + 1 -> 128   signed: 127 + 1 -> -128
FFH + 01H = 00H  S=0 Z=1 AC=1 P=1 CY=1 | V=0
   unsigned: 255 + 1 -> 0   signed: -1 + 1 -> 0
80H + 80H = 00H  S=0 Z=1 AC=0 P=1 CY=1 | V=1
   unsigned: 128 + 128 -> 0   signed: -128 + -128 -> 0
05H - 07H = FEH  S=1 Z=0 AC=0 P=0 CY=1 | V=0
   unsigned: 5 - 7 -> 254   signed: 5 - 7 -> -2

চারটি লাইন চারটি আলাদা গল্প। 7FH + 01H: unsigned ঠিক (128), signed ভুল (−128), তাই CY = 0 কিন্তু V = 1. FFH + 01H: ঠিক উল্টো, unsigned ভুল, signed ঠিক (−1 + 1 = 0). 80H + 80H: দুটোই ভুল। 05H − 07H: borrow হয়েছে (CY = 1), কিন্তু signed ফল −2 ঠিক। পাঁচটি flag-এর মান কোর্সের 8085 simulator-এর সঙ্গে হুবহু মেলে; নিচের stepper সেই সত্যিকারের trace থেকে।

1MVI A,7FH2ADI 01H   ; 127 + 13MVI A,0FFH4ADI 01H   ; 255 + 15MVI A,80H6ADI 80H   ; 128 + 1287MVI A,05H8SUI 07H   ; 5 − 7
ফল আর flag
A
S Z AC P CY
unsigned
signed
8086
  1. 127 + 1. A = 80H: unsigned অর্থে 128, ঠিক; signed অর্থে −128, ভুল। CY = 0, কারণ বিট ৭ থেকে কিছু বেরোয়নি। S = 1, AC = 1 (F + 1 নিচের nibble থেকে carry), P = 0 (একটিমাত্র 1). 8085 overflow জানায় না; 8086-এর একই হিসাবে OF = 1.
  2. 255 + 1. A = 00H, Z = 1, CY = 1: unsigned ফল আঁটেনি। কিন্তু signed অর্থে −1 + 1 = 0, একদম ঠিক, তাই 8086-এ OF = 0. এই কারণেই signed হিসাবের পরে CY দেখে overflow ধরা ভুল।
  3. 128 + 128. আবার 00H, CY = 1. Signed অর্থে −128 + (−128) = −256, যা ৮ বিটে আঁটে না: দুটি ঋণাত্মক যোগে ফলের চিহ্ন ধনাত্মক। 8086-এ CF = 1, OF = 1, দুটোই।
  4. 5 − 7. A = FEH, CY = 1 মানে borrow. Signed অর্থে −2, ঠিক, তাই OF = 0. AC = 0 এসেছে Spec decision 4-এর নিয়মে (8080-এর মতো, A + NOT B + 1-এর বিট ৩-এর carry); 8086-এর AF এখানে 1, কারণ 8086 বিয়োগে AF-কে borrow অর্থে রাখে।

8086-এর কলামটি এসেছে সত্যিকারের run থেকে: একই চার জোড়া হিসাব NASM 3.02-এ assemble করে Unicorn-এ চালানো (python -B run8086.py flags86.asm --trace; লাইনগুলো ছোট করা, শুধু AX আর flag). Flag-এর অক্ষর O D I T S Z A P C ক্রমে, যেটি বন্ধ সেখানে -:

1000:0102  0401   add al,0x1    AX=0080  O-I-S-A--
1000:0106  0401   add al,0x1    AX=0000  --I--ZAPC
1000:010A  0480   add al,0x80   AX=0000  O-I--Z-PC
1000:010E  2C07   sub al,0x7    AX=00FE  --I-S-A-C

আর Cortex-M? বাজারঘর board-এ একটি firmware adds আর subs চালিয়ে সঙ্গে সঙ্গে mrs দিয়ে APSR পড়ে (সত্যিকারের run, একই numsys.elf; ৩২ বিটের হিসাব, তাই সংখ্যাগুলো বড়):

[     0.0716 ms] UART: adds 0x7FFFFFFF+1 -> 0x80000000 N=1 Z=0 C=0 V=1
[     0.1400 ms] UART: adds 0xFFFFFFFF+1 -> 0x00000000 N=0 Z=1 C=1 V=0
[     0.2085 ms] UART: subs 5-7          -> 0xFFFFFFFE N=1 Z=0 C=0 V=0
[     0.2767 ms] UART: subs 7-5          -> 0x00000002 N=0 Z=0 C=1 V=0

প্রথম দুটি লাইন 8086-এর মতোই। কিন্তু শেষ দুটি দেখুন: 5 − 7-এ borrow হয়েছে, অথচ C = 0; 7 − 5-এ borrow নেই, আর C = 1. ARM-এ বিয়োগের পরে C-এর অর্থ “borrow হয়নি”, 8085 আর 8086-এর ঠিক উল্টো। ARM-এর BHS (unsigned ≥) শর্ত এই কারণেই C = 1 দেখে। ARM বিয়োগকে A + NOT B + 1 হিসেবে করে আর সেই যোগের carry সরাসরি C-তে রাখে; 8085-এর মতো উল্টে নেয় না। N = 1, কারণ ফল 0xFFFFFFFE-এর বিট ৩১ = 1, আর signed অর্থে −2 ঠিক, তাই V = 0.

আরও গভীরে: 8085-এর flag register-এর “অব্যবহৃত” বিট ১ আর বিট ৫ আসলে পুরোপুরি ফাঁকা নয়। Chip-টি বাজারে আসার কয়েক বছর পরে স্বাধীন গবেষকেরা দেখান যে বিট ১-এ একটি signed overflow flag (প্রায়ই V নামে) আর বিট ৫-এ আরেকটি flag (K বা X5 নামে) আছে, সঙ্গে কয়েকটি নথিভুক্ত নয় এমন নির্দেশ। Intel এগুলো কখনো আনুষ্ঠানিকভাবে নথিভুক্ত করেনি, তাই পরীক্ষা, simulator আর এই কোর্স ধরে নেয় 8085-এ overflow flag নেই (Spec decision 1 ও 3). 8086-এ (১৯৭৮) OF আনুষ্ঠানিকভাবে এলো, আর ARM-এর প্রথম নকশা থেকেই N Z C V চারটি flag ছিল। RISC-V আবার কোনো flag register রাখে না: শর্ত সরাসরি তুলনা-নির্দেশে।

৫ · BCD — দামের display আর DAA-র এক ঝলক

স্মার্ট স্কেলের display-এ দাম “81.88”. Firmware-এ দাম থাকে পয়সায়, binary integer হিসেবে: 8188 = 0x1FFC. দেখাতে হলে এই সংখ্যা থেকে চারটি দশমিক অঙ্ক বের করতে হয়, যার মানে বারবার ১০ দিয়ে ভাগ। Cortex-M3-এ hardware ভাগের নির্দেশ (UDIV) আছে, তাই কাজটি সহজ। কিন্তু 8085-এর মতো CPU-তে ভাগের কোনো নির্দেশ নেই; ভাগ মানে বারবার বিয়োগের loop. তাই পুরোনো ক্যালকুলেটর, ঘড়ি আর মিটারে সংখ্যা রাখা হতো সরাসরি দশমিক অঙ্কে: BCD.

Packed BCD-এ এক byte-এ দুটি অঙ্ক: 81 = 81H = 1000 0001. Unpacked BCD-এ প্রতি byte-এ একটি অঙ্ক, ওপরের nibble 0 (বা ASCII-তে 3): 8 = 08H, ASCII-তে 38H. Packed BCD-র সুবিধা: প্রতিটি nibble সরাসরি একটি অঙ্ক, তাই display-এ পাঠানো সহজ। অসুবিধা: যোগের পরে ফল ভুল হতে পারে, কারণ adder binary-তে যোগ করে। যেমন 83H + 88H binary-তে 10BH; নিচের nibble B কোনো দশমিক অঙ্কই নয়। সংশোধন করে DAA (Decimal Adjust Accumulator): নিচের nibble ৯-এর বেশি বা AC = 1 হলে 06H যোগ, ওপরের nibble ৯-এর বেশি বা CY = 1 হলে 60H যোগ (পুরো নিয়ম Spec decision 5). কেন ৬? কারণ hex-এ ১৬টি ঘর, দশমিকে ১০টি; ফাঁকা ৬টি ঘর লাফিয়ে পার হতে হয়।

বাজারঘরের একজন ক্রেতা দুটি জিনিস কিনলেন: ১৫০ g আলু, দাম 9.83 টাকা, আর ১২৫০ g আলু, দাম 81.88 টাকা (README-র worked numbers). 8085 দুটি দাম packed BCD-তে যোগ করবে, প্রতিটি দাম দুই byte, পয়সার byte আগে: 9.83 = 83H, 09H, 81.88 = 88H, 81H. প্রথমে পয়সা যোগ, তারপর টাকা, আগের carry-সহ (ADC). নিচের মানগুলো সত্যিকারের trace থেকে (python -B sim8085.py trace price_bcd.asm; ১৩টি নির্দেশ, ১০৭ T-state).

1LDA 2050H   ; 832MOV B,A3LDA 2052H   ; 884ADD B5DAA6STA 2054H7LDA 2051H   ; 098MOV B,A9LDA 2053H   ; 8110ADC B11DAA12STA 2055H13HLT
Register আর memory
A
B
CY · AC
2054H 2055H
  1. পয়সার দুটি byte. LDA দিয়ে প্রথম দামের পয়সা 83H B-তে, তারপর দ্বিতীয় দামের 88H A-তে। LDA আর MOV কোনো flag বদলায় না, তাই সব flag এখনো 0.
  2. Binary যোগ. 83H + 88H = 10BH: A = 0BH, CY = 1. AC = 0, কারণ 3 + 8 = 11, যা নিচের nibble-এই আঁটে। দশমিকে উত্তর হওয়ার কথা 83 + 88 = 171, কিন্তু A-তে আছে “0B”: দুটি অঙ্কই ভুল।
  3. DAA, দুটি সংশোধন. নিচের nibble B > 9, তাই +06H; CY = 1, তাই +60H. 0BH + 66H = 71H, আর CY = 1 থাকে: পয়সা 71, এক টাকা হাতে। AC = 1 এসেছে সংশোধনের নিজের যোগ থেকে (B + 6).
  4. পয়সা জমা, টাকা আনা. STA 71H রাখল 2054H-এ। তারপর টাকার byte দুটি: B = 09H, A = 81H. কোনো নির্দেশ flag ছোঁয়নি, তাই CY = 1, পয়সার হাতের এক টাকা, এখনো বেঁচে আছে।
  5. ADC: carry-সহ যোগ. 81H + 09H + 1 = 8BH. CY = 0, AC = 0. আবার নিচের nibble B, দশমিক নয়।
  6. শেষ DAA. নিচের nibble > 9, তাই +06H: 91H. ওপরের nibble 8, ৯-এর বেশি নয়, CY = 0, তাই +60H লাগল না। Memory-তে 71 91: 91.71 টাকা = 9.83 + 81.88. ঠিক।

BCD-র ফল display-এ পাঠানোও সহজ। Seven-segment display-এর সাতটি দাগের নাম a থেকে g; প্রতিটি অঙ্কের জন্য কোন দাগ জ্বলবে, তা একটি byte-এ লেখা যায়, বিট ০ = a থেকে বিট ৬ = g (common-cathode display-এ 1 মানে জ্বলবে)।

ছবি ৫.৩ — ৭-segment অঙ্ক “9” আর তার byte

বিট ৬…০ = g f e d c b a; 1 = জ্বলবে

Seven-segment display-এ অঙ্ক 9 abcdefg g f e d c b a 1 1 0 1 1 1 1 9 → 6FH 1 → 06H 7 → 07H 8 → 7FH ধূসর = নেভা (e)
ছবি ৫.৩ — “9”-এ শুধু e নেভা, তাই 0110 1111 = 6FH. এই সংকেত-টেবিল display-এর তার জোড়ার ধরনের ওপর নির্ভর করে: common-anode display-এ 0 মানে জ্বলবে, তখন প্রতিটি বিট উল্টে যায় (বিট ৭-এর দশমিক বিন্দু নেভা ধরলে 9 = 90H).

নিচের ব্লক একই দুটি দাম Spec decision 5-এর DAA দিয়ে যোগ করে, তারপর প্রতিটি nibble-কে segment byte-এ বদলে লেখার অক্ষরে একটি ছোট display আঁকে।

# দুটি দাম packed BCD-তে যোগ (DAA, Spec decision 5), তারপর 7-segment display
def daa(a, cy, ac):
    corr = 0
    lo, hi = a & 0xF, a >> 4
    if lo > 9 or ac: corr |= 0x06
    if hi > 9 or cy or (hi >= 9 and lo > 9): corr |= 0x60; cy = 1
    return (a + corr) & 0xFF, cy

def add_bcd(x, y, cin):                 # ADD/ADC তারপর DAA, এক byte
    s = x + y + cin
    ac = ((x & 0xF) + (y & 0xF) + cin) >> 4
    return daa(s & 0xFF, s >> 8, ac)

p1, p2 = [0x83, 0x09], [0x88, 0x81]    # 9.83 আর 81.88 টাকা, পয়সার byte আগে
lo, c = add_bcd(p1[0], p2[0], 0)
hi, c = add_bcd(p1[1], p2[1], c)
print(f"পয়সা: {lo:02X}H, টাকা: {hi:02X}H, CY={c}  ->  {hi:X}.{lo:02X} টাকা")

SEG = [0x3F, 0x06, 0x5B, 0x4F, 0x66, 0x6D, 0x7D, 0x07, 0x7F, 0x6F]  # gfedcba
digits = [hi >> 4, hi & 0xF, lo >> 4, lo & 0xF]   # প্রতিটি nibble একটি অঙ্ক
print("segment byte:", " ".join(f"{SEG[d]:02X}H" for d in digits))
rows = ["", "", ""]
for i, d in enumerate(digits):
    m = SEG[d]
    on = lambda bit, ch: ch if m >> bit & 1 else " "
    rows[0] += " " + on(0, "_") + "  "
    rows[1] += on(5, "|") + on(6, "_") + on(1, "|") + " "
    rows[2] += on(4, "|") + on(3, "_") + on(2, "|") + ("." if i == 1 else " ")
print("\n".join(rows))

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

পয়সা: 71H, টাকা: 91H, CY=0  ->  91.71 টাকা
segment byte: 6FH 06H 07H 06H
 _       _
|_|   |   |   |
 _|   |.  |   | 

Python-এর DAA আর simulator-এর DAA একই উত্তর দিল: 71H আর 91H. লক্ষ করুন, BCD-তে 91H-কে hex হিসেবে ছাপলেই দশমিক “91” আসে; কোনো ভাগ লাগেনি। প্রতিটি nibble সরাসরি SEG টেবিলের index, আর display-এর দশমিক বিন্দু (dp, অষ্টম দাগ) দ্বিতীয় অঙ্কের পরে বসানো। 8085-এ এই টেবিল-দেখার কাজটি সাধারণত memory-তে রাখা একটি lookup table আর MOV A,M দিয়ে হয়; বাস্তব display-এ প্রতিটি byte একটি output port-এ যায়, যেমন 8255 PPI-এর port (পর্ব ২৪)।

সীমাবদ্ধতাও মনে রাখুন। 8085-এর DAA শুধু যোগের পরে কাজ করে; বিয়োগের জন্য 8085-এ আলাদা নির্দেশ নেই, তাই BCD বিয়োগ করতে হয় 9-এর বা 10-এর complement নিয়ে যোগ করে। 8086-এ বিয়োগের জন্য DAS আর unpacked BCD-র জন্য AAA, AAS, AAM, AAD আছে (পর্ব ১৬, 8086-এর instruction set). ARM Cortex-M-এ BCD-র কোনো নির্দেশ নেই; সেখানে binary-তে হিসাব করে শেষে অঙ্ক বের করাই নিয়ম। 8085-এ BCD-র পুরো program পর্ব ১১ (8085 assembly program)-এ।

BCD আর DAA পুরোনো। ১৯৭১ সালের Intel 4004 তৈরি হয়েছিল একটি ক্যালকুলেটরের জন্য, আর তার নির্দেশমালাতেই দশমিক সংশোধনের একটি DAA নির্দেশ ছিল। 8080 আর ১৯৭৬ সালের 8085 সেই ধারা রাখে, AC flag-টি আছেই এই একটি কাজের জন্য। আজও অনেক real-time clock chip সময় আর তারিখ BCD-তে রাখে, কারণ ঘড়ির display-এ অঙ্কগুলো সরাসরি পাঠানো যায়।

পরীক্ষা ও ইন্টারভিউতে: বিশ্ববিদ্যালয়, চাকরি বা ইন্টারভিউর পরীক্ষায় এই ধরনের প্রশ্ন প্রায়ই আসে:

  • Carry আর overflow-এর পার্থক্য? Carry = unsigned ফল আঁটেনি (MSB থেকে carry বেরিয়েছে); overflow = signed ফল আঁটেনি (MSB-তে ঢোকা আর বেরোনো carry আলাদা)।
  • 8085-এ কোন flag নেই যা 8086-এ আছে? Overflow (OF); এছাড়া 8086-এ নিয়ন্ত্রণের flag DF, IF, TF.
  • AC flag কেন? শুধু DAA-র জন্য: নিচের nibble থেকে carry হলে DAA জানে 06H যোগ করতে হবে।
  • −1-এর ৮ বিট two's complement? FFH; −128 = 80H, যার negation আবার 80H.
  • ৪৭-এর packed BCD? 47H = 0100 0111; binary-তে ৪৭ = 2FH.

৬ · Endianness — memory-তে byte-এর ক্রম

8085-এর register আট বিটের, কিন্তু ঠিকানা আর অনেক মান ষোলো বিটের। স্মার্ট স্কেলের ADC ১২ বিটের: 1400 g-এ count 1380 = 0564H, যা এক byte-এ আঁটে না। Memory-তে রাখতে দুটি byte লাগে, আর প্রশ্ন ওঠে: কোনটি আগে, ছোট ঠিকানায়? এই নিয়মের নাম endianness. Little-endian-এ ছোট byte (64H) আগে, big-endian-এ বড় byte (05H) আগে। 8085 little-endian: SHLD আগে L, তারপর H লেখে; assembler-এর DW-ও একই ক্রমে (Spec decision 9). নিচের মানগুলো সত্যিকারের trace থেকে (python -B sim8085.py trace endian.asm).

1LXI H,0564H  ; 13802SHLD 2050H3LXI H,1FFCH  ; 81884SHLD 2052H5LHLD 2050H6HLT7DW 1FFCH     ; 2054H
H, L আর memory
H L
2050H…2055H
2050H-এর word
  1. শুরু. LXI H,0564H: H = 05H (বড় byte), L = 64H (ছোট byte). 2054H-এ আগেই FC 1F বসে আছে: assembler program load করার সময় DW 1FFCH লিখে রেখেছে, ছোট byte আগে।
  2. SHLD 2050H. নির্দেশটি L-কে রাখে 2050H-এ, H-কে 2051H-এ: memory-তে 64 05. Memory-র দিক থেকে পড়লে সংখ্যাটি “উল্টো” দেখায়, কিন্তু 8085-এর নিয়মে এটিই 1380.
  3. দাম 8188 পয়সা. 1FFCH একইভাবে নামল 2052H-এ: FC 1F. এখন 2052H আর 2054H-এর দুটি word একই, একটি নির্দেশ দিয়ে লেখা, অন্যটি assembler দিয়ে: দুই পথেই ক্রম একই।
  4. LHLD 2050H: ফেরত পড়া. 2050H থেকে L, 2051H থেকে H: HL = 0564H. যে নিয়মে লেখা, সেই নিয়মে পড়লে সংখ্যা অক্ষত থাকে। সমস্যা হয় দুই নিয়মের যন্ত্র বা protocol মিললে।
  5. ভুল ক্রমে পড়লে. ধরুন একটি big-endian যন্ত্র এই memory-র কপি পেল আর 2050H-কে বড় byte ধরল: 6405H = 25605 count. স্কেল তখন ৩৬,০০০ g-এর বেশি দেখাত (৫০০০ g-এর সীমা পেরিয়ে OVERLOAD), অথচ ওজন মাত্র ১৪০০ g.

8086 আর প্রায় সব বাজারের Cortex-M chip-ও little-endian. ARMv7-M-এ data-র endianness chip-নির্মাতা reset-এর সময় ঠিক করে দেন, আর AIRCR register-এর ENDIANNESS বিট সেটি শুধু জানায়; বাস্তবে big-endian Cortex-M প্রায় দেখা যায় না। বাজারঘর board-এ দাম 8188 একটি uint32_t হিসেবে SRAM-এ রেখে byte ধরে পড়লে (সত্যিকারের run, একই numsys.elf):

[     0.3276 ms] UART: 8188 at 0x20000000: 0xFC 0x1F 0x00 0x00

কিন্তু বাইরের জগৎ সবসময় এমন নয়। TCP/IP header-এর সংখ্যা big-endian, যাকে বলে network byte order. MQTT 3.1.1-এর দুই byte-এর সংখ্যা (যেমন topic-এর দৈর্ঘ্য) big-endian, OASIS standard-এর ১.৫.২ অংশ অনুযায়ী (পর্ব ৭৩-এ MQTT-এর packet byte ধরে দেখা হবে)। আর cold room-এর sensor বড় byte আগে পাঠায়, যা stepper ৫.১-এ দেখেছেন। তাই firmware-এ নিয়ম: বাইরের data কখনো memcpy দিয়ে সরাসরি uint16_t-এ ঢালবেন না; byte ধরে shift আর OR দিয়ে জোড়া লাগান, যেমন (msb << 8) | lsb. এই কোড যেকোনো endianness-এর CPU-তে একই ফল দেয়। দরকার হলে Cortex-M-এর rev নির্দেশ এক নির্দেশে চারটি byte উল্টায়; __builtin_bswap32 লিখলে Clang ঠিক এটিই দেয় (সত্যিকারের run, conv.c):

swap32:                      @ return __builtin_bswap32(x);
	rev	r0, r0
	bx	lr

৭ · Fixed-point-এর প্রথম পরিচয় — float ছাড়া টাকা, গ্রাম আর °C

অনেক microcontroller-এ floating-point hardware নেই (Cortex-M3-এ নেই, Cortex-M4F-এ আছে)। float তখন software-এ চলে, ধীরে, আর টাকার হিসাবে 0.1-এর মতো সংখ্যা binary float-এ হুবহু রাখাই যায় না। তাই এমবেডেড কাজে ভগ্নাংশ রাখার প্রধান উপায় fixed-point: একটি integer, যার “দশমিক বিন্দু” কোথায়, তা আগে থেকে ঠিক করা। এই কোর্সে আপনি ইতিমধ্যে তিনটি দেখেছেন:

মানInteger-এ যা রাখাএকক (scale)উদাহরণ
দামপয়সা১/১০০ টাকা (দশমিক)8188 = 81.88 টাকা
দরপয়সা প্রতি kg১/১০০ টাকা6550 = 65.50 টাকা/kg
Sensor-এর wordsigned ১৬ বিট১/২৫৬ °C (binary)0xFF80 = −0.50 °C
t16signed ৩২ বিট১/১৬ °C (binary)−8 = −0.50 °C; 128 = 8.00 °C

Binary scale-এর fixed-point-এর নাম লেখা হয় Q format-এ: Qm.n মানে m বিট পূর্ণ অংশ (এখানে চিহ্ন-বিটসহ, Computer Architecture কোর্সের প্রথা মেনে) আর n বিট ভগ্নাংশ। Sensor-এর ১৬ বিটের word তাহলে Q8.8. কিছু বই চিহ্ন-বিট আলাদা গোনে আর একে Q7.8 বলে; নাম দেখে না, বিটের সংখ্যা আর scale দেখে মেলাবেন।

Fixed-point-এর সবচেয়ে বড় ঝুঁকি overflow, কারণ গুণের ফল দ্রুত বড় হয়। স্কেলের দামের সূত্র (README): price_paisa = (net_g × 6550 + 500) ÷ 1000, integer ভাগ, যা অর্ধেকে ওপরে গোল করে। ১২৫০ g-এর জন্য ধাপে ধাপে:

  1. গুণ: 1250 × 6550 = 8,187,500 (একক: g × পয়সা/kg).
  2. গোল করার জন্য অর্ধেক যোগ: 8,187,500 + 500 = 8,188,000.
  3. ১০০০ দিয়ে ভাগ (g থেকে kg): 8,188,000 ÷ 1000 = 8188 পয়সা = 81.88 টাকা.

মাঝের 8,188,000 ষোলো বিটে (সর্বোচ্চ 65535) আঁটে না। ৫০০০ g-এর সীমায় গুণফল 32,750,500, যা ২৪ বিটেও (16,777,216) আঁটে না, কিন্তু ৩২ বিটে সহজে আঁটে। ষোলো বিটে রাখলে কোন ওজন পর্যন্ত ঠিক থাকত? 9 × 6550 + 500 = 59,450 আঁটে, 10 g-এ 66,000 আঁটে না: মাত্র ৯ g! নিচের C কোড (Wandbox-এ সত্যিকারের compiler) একসঙ্গে sign extension, এই overflow আর memory-র byte-ক্রম দেখায়।

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

int main(void)
{
    uint16_t raw = 0xFF80;                       /* cold room sensor: -0.50 C */
    int32_t t16 = (int32_t)(int16_t)raw >> 4;    /* sign extension */
    int32_t bad = raw >> 4;                      /* unsigned shift: sign lost */
    printf("t16=%d (%d/100 C)  bad=%d\n", (int)t16, (int)(t16 * 25 / 4), (int)bad);

    uint32_t net_g = 1250;                       /* scale: 1250 g at 6550 paisa/kg */
    uint32_t p32 = (net_g * 6550u + 500u) / 1000u;
    uint16_t m16 = (uint16_t)(net_g * 6550u + 500u);   /* a 16-bit register */
    printf("32-bit: %u paisa  16-bit: %u paisa\n", (unsigned)p32, (unsigned)(m16 / 1000u));

    int8_t s = (int8_t)0xC8;                     /* 200 as a signed byte */
    uint8_t u = 0xC8;
    printf("int8 %d -> int32 %d, uint8 %u -> int32 %d\n", s, (int32_t)s, u, (int32_t)u);

    uint32_t price = 8188;                       /* 81.88 Tk */
    uint8_t b[4];
    memcpy(b, &price, sizeof b);
    printf("8188 = 0x%08X, bytes in memory: %02X %02X %02X %02X\n",
           (unsigned)price, b[0], b[1], b[2], b[3]);
    return 0;
}

আসল আউটপুট (Wandbox-এর GCC):

t16=-8 (-50/100 C)  bad=4088
32-bit: 8188 paisa  16-bit: 61 paisa
int8 -56 -> int32 -56, uint8 200 -> int32 200
8188 = 0x00001FFC, bytes in memory: FC 1F 00 00

প্রথম লাইন stepper ৫.১-এর দুই পথ: −8 আর 4088. দ্বিতীয় লাইনে ৩২ বিটে 8188 পয়সা, কিন্তু গুণফলকে ১৬ বিটের register-এ আটকালে 8,188,000 থেকে থাকে শুধু 65536-এর ভাগশেষ, 61536, আর দাম দাঁড়ায় 61 পয়সা: ক্রেতা ৮১ টাকার আলু পেতেন ৬১ পয়সায়। তৃতীয় লাইনে একই byte C8H: signed type-এ −56 হয়ে sign extension-এ −56-ই থাকে, unsigned-এ 200. শেষ লাইনে host CPU-ও little-endian, তাই byte-ক্রম বাজারঘর board-এর মতোই।

১৬ বিটের এই ফাঁদ শুধু কাল্পনিক নয়। C-তে int-এর মাপ CPU-র ওপর নির্ভর করে: Cortex-M-এ ৩২ বিট, কিন্তু 8-বিটের AVR-এ (যেমন ATmega328P) avr-gcc আর Clang-এ ১৬ বিট। একই কোড দুই target-এ compile করে দেখা যাক (সত্যিকারের run, Clang 22.1.8, -O2; ফাইলে uint16_t net_g = 1250; আর return (net_g * 6550u + 500u) / 1000u;, ধ্রুবক বলে compiler নিজেই হিসাব করে ফলটি বসিয়ে দেয়):

; AVR: --target=avr -mmcu=atmega328p
price_bad:
	ldi	r24, 61
	ldi	r25, 0
	ret
int_bytes:                   ; return sizeof(int);
	ldi	r24, 2
	ldi	r25, 0
	ret
@ Cortex-M3: --target=thumbv7m-none-eabi -mcpu=cortex-m3
price_bad:
	movw	r0, #8188
	bx	lr
int_bytes:
	movs	r0, #4
	bx	lr

AVR-এ sizeof(int) = 2, তাই 6550u ১৬ বিটের unsigned int, আর হিসাব ১৬ বিটেই wrap করে 61 দেয়। Cortex-M-এ একই লাইন 8188. সমাধান: গুণের আগে একটি operand-কে চওড়া type-এ তুলুন, (uint32_t)net_g * 6550u; AVR-এও তখন উত্তর 8188 (একই run-এ price_good ফেরত দেয় byte 252, 31, 0, 0 = 0x00001FFC). C কোর্সের পর্ব ০৮-এর integer promotion-এর নিয়মই এখানে কাজ করছে। গুণ, ভাগ, গোল করা আর saturating arithmetic-এর পুরো কৌশল পর্ব ৪০ (Fixed-point গণিত)-এ; fixed-width type-এর অভ্যাস পর্ব ৩৪ (Embedded C)-এ।

নিয়ম

প্রতিটি fixed-point মানের পাশে মন্তব্যে তিনটি জিনিস লিখুন: একক (পয়সা, ১/১৬ °C), type-এর বিট আর চিহ্ন (int32_t), আর সবচেয়ে বড় সম্ভাব্য মান। তারপর প্রতিটি গুণের জন্য হাতে হিসাব করুন: সবচেয়ে বড় মান × সবচেয়ে বড় মান কি type-এ আঁটে?

৮ · AI-এর যুগে সংখ্যার হিসাব যাচাই

AI assistant রূপান্তরের ছোট কাজ দ্রুত করে দেয়, কিন্তু এই বিষয়ের ভুলগুলো ঠিক সেই জায়গায়, যেখানে তার উত্তর আত্মবিশ্বাসী শোনায়। সাধারণ ভুলের তালিকা আর ধরার উপায়:

AI প্রায়ই যা করেকীভাবে ধরবেন
8085-এ overflow flag আছে বলে ধরা, বা 8086/Z80-এর নির্দেশ (DAS, JO) 8085-এ লেখাIntel 8085 manual-এর নির্দেশ-তালিকা; কোর্সের simulator assemble করতে না পারলে নির্দেশটি নেই
ARM-এ বিয়োগের পরে C = 1 মানে borrow ধরাARMv7-M ARM; বাজারঘর board-এ subs চালিয়ে APSR পড়া
Sensor-এর signed মান uint16_t-এ রেখে shift করাঋণাত্মক পরীক্ষার মান (−0.50, −25 °C) দিয়ে চালানো; compiler-এর assembly-তে asrs না lsrs, দেখা
নির্দিষ্ট microcontroller-এর register-এর ঠিকানা বা বিট বানিয়ে বলাসেই chip-এর reference manual; কখনো অন্য chip-এর ঠিকানা ধার করবেন না
গুণফলের মাপ না দেখে fixed-point সূত্র দেওয়া; int সবসময় ৩২ বিট ধরাসবচেয়ে বড় মানে হাতে হিসাব; target-এর sizeof(int); AVR আর ARM দুই target-এ compile
বাইরের byte memcpy দিয়ে struct-এ ঢালা, endianness না ভেবেDatasheet বা standard-এ byte-ক্রম; জানা মান (0x0400 = 4.00 °C) দিয়ে পরীক্ষা

AI-কে কাজে লাগাতে আগে প্রসঙ্গ আর যাচাইয়ের পথ বলে দিন:

আমি একটি ARM Cortex-M3 (Clang, -O2) firmware লিখছি। একটি TMP102-এর মতো sensor I2C দিয়ে দুটি byte দেয়, বড় byte আগে; মান ১২ বিটের two's complement, বাঁয়ে বসানো, প্রতি ধাপ 0.0625 °C. ১. দুটি uint8_t (msb, lsb) থেকে তাপমাত্রা শতাংশ °C-এ (int32_t) ফেরত দেয় এমন একটি C function লেখো, float ছাড়া। ২. প্রতিটি লাইনের পাশে মন্তব্যে বলো কোন মান signed, কোনটি unsigned, আর কোথায় sign extension হচ্ছে। Implementation-defined কিছু থাকলে আলাদা করে বলো। ৩. যাচাইয়ের জন্য এই ইনপুটগুলোর প্রত্যাশিত ফল দাও: (0x04,0x00), (0xFF,0x80), (0xE7,0x00), (0x7F,0xF0), (0x80,0x00). নিশ্চিত না হলে অনুমান কোরো না, বলো। ৪. কোনো register-এর ঠিকানা বা chip-এর বিট লাগলে নিজে বানিয়ো না; আমাকে জিজ্ঞেস করো।

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

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

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

প্র ০১8085-এ overflow flag নেই, 8086 আর ARM-এ আছে, RISC-V-এ কোনো flag-ই নেই। এই তিনটি সিদ্ধান্তের পেছনে কী যুক্তি, আর 8085-এ signed overflow কীভাবে ধরবেন?

8085 এসেছে 8080-এর ধারা থেকে, আর 8080-এর নকশা ১৯৭০-এর দশকের শুরুর: তখনকার প্রধান কাজ ছিল ক্যালকুলেটর, terminal আর নিয়ন্ত্রণ-যন্ত্র, যেখানে বেশিরভাগ হিসাব unsigned বা BCD. তাই flag-এর তালিকায় এলো carry, BCD-র জন্য auxiliary carry, আর parity (serial যোগাযোগে ভুল ধরার কাজে লাগত)। Signed overflow-এর আলাদা flag রাখা হয়নি। ভেতরে একটি overflow বিট আসলে ছিল, কিন্তু Intel কখনো নথিভুক্ত করেনি, তাই কোনো নির্ভরযোগ্য program সেটি ব্যবহার করতে পারে না।

১৯৭৮ সালের 8086-এর লক্ষ্য ছিল ১৬ বিটের সাধারণ কাজের কম্পিউটার, যেখানে high-level ভাষার signed integer প্রতিদিনের ব্যাপার। তাই OF আনুষ্ঠানিক হলো, সঙ্গে signed তুলনার শর্ত (JL, JG) আর INTO নির্দেশ। ARM (Acorn, ১৯৮৫) শুরু থেকেই N Z C V রাখে, আর প্রায় প্রতিটি নির্দেশ শর্তসাপেক্ষে চালানোর সুবিধার জন্য flag সেখানে কেন্দ্রীয়। RISC-V উল্টো পথে গেছে: flag register একটি “লুকানো অবস্থা”, যা pipeline আর out-of-order নকশায় বাড়তি নির্ভরতা তৈরি করে; তাই RISC-V-এ শর্ত সরাসরি তুলনা-লাফে (blt, bltu), আর overflow দরকার হলে কয়েকটি নির্দেশ দিয়ে software-এ ধরতে হয়।

8085-এ signed overflow ধরার নিয়ম চিহ্নের যুক্তি থেকেই আসে। যোগের আগে দুটি operand-এর বিট ৭ দেখুন। আলাদা হলে overflow অসম্ভব। এক হলে, যোগের পরে ফলের বিট ৭ যদি সেই চিহ্ন থেকে আলাদা হয়, তাহলে overflow. কোডে: দুটি operand-এর XRA করে বিট ৭ পরীক্ষা, তারপর একটি operand আর ফলের XRA. কয়েকটি নির্দেশ বেশি লাগে, কিন্তু কাজ হয়। এই পর্বের Python ব্লকের (a ^ r) & (b ^ r) & 0x80 ঠিক এই নিয়মই এক লাইনে।

মূল উপলব্ধি: Flag কোন কাজের জন্য রাখা হবে, তা নকশার যুগের প্রধান কাজ ঠিক করে দেয়; যে flag নেই, তার কাজ software-এ চিহ্নের নিয়ম দিয়ে করা যায়।

প্র ০২আধুনিক ৩২ বিটের microcontroller-এ BCD-র নির্দেশই নেই। তাহলে BCD কি এখন শুধু পরীক্ষার বিষয়, নাকি বাস্তবে এখনো দরকার?

Cortex-M-এ DAA-র মতো কোনো নির্দেশ নেই, কারণ হিসাব binary-তে করে শেষে অঙ্ক বের করা এখন সস্তা। Cortex-M3-এ hardware ভাগ আছে, আর compiler ১০ দিয়ে ভাগকে প্রায়ই একটি গুণ আর shift-এ বদলে দেয়। একটি চার অঙ্কের দাম থেকে অঙ্ক বের করতে কয়েক ডজন নির্দেশ লাগে, যা মানুষের চোখের গতির তুলনায় কিছুই নয়। তাই firmware-এর ভেতরের হিসাব binary-তে রাখাই নিয়ম: যোগ, তুলনা, গুণ সব দ্রুত আর সহজ।

তবু BCD হারিয়ে যায়নি, কারণ যেখানে সংখ্যা মূলত দশমিক অঙ্ক হিসেবেই জন্মায় বা দেখানো হয়, সেখানে এটি সুবিধাজনক। অনেক real-time clock chip সেকেন্ড, মিনিট, ঘণ্টা আর তারিখ BCD register-এ রাখে: register পড়ে প্রতিটি nibble সরাসরি display-এ পাঠানো যায়, আর মানুষ debugger-এ 0x59 দেখেই বোঝেন ৫৯ সেকেন্ড। কিছু মিটার আর পুরোনো যন্ত্রের protocol-ও BCD-তে সংখ্যা পাঠায়। আর্থিক software-এ দশমিক নির্ভুলতার জন্য packed decimal পুরোনো mainframe ভাষায় প্রচলিত, আর IEEE 754-এর ২০০৮ সালের সংস্করণে দশমিক floating-point-এর রূপও যোগ হয়েছে।

তাই firmware লেখকের জন্য ব্যবহারিক দক্ষতা দুটি: BCD register পড়া আর লেখা ((v >> 4) * 10 + (v & 0x0F) দিয়ে binary-তে, আর উল্টো পথে ((n / 10) << 4) | (n % 10)), আর ভুল BCD চেনা: কোনো nibble ৯-এর বেশি মানে data নষ্ট বা ভুল পড়া। পরীক্ষায় DAA আসে কারণ এটি carry, AC আর flag-এর যুক্তি একসঙ্গে যাচাই করে; সেই যুক্তি বোঝা firmware-এর যেকোনো bit-level debugging-এ কাজে লাগে।

মূল উপলব্ধি: ভেতরের হিসাব binary-তে, সীমানায় (display, ঘড়ির chip, protocol) BCD; দুইয়ের মধ্যে রূপান্তর আর ভুল BCD চেনা আজও দরকারি দক্ষতা।

প্র ০৩Little-endian আর big-endian নামগুলো কোথা থেকে এলো, আর CPU-র জগতে little-endian কেন প্রায় সর্বত্র, অথচ network-এ big-endian?

নাম দুটি এসেছে Jonathan Swift-এর “Gulliver's Travels” থেকে, যেখানে দুই রাজ্য যুদ্ধ করে সিদ্ধ ডিম কোন প্রান্ত থেকে ভাঙা উচিত তা নিয়ে। ১৯৮০ সালে Danny Cohen “On Holy Wars and a Plea for Peace” নামের একটি লেখায় byte-ক্রমের তর্ককে এই গল্পের সঙ্গে তুলনা করেন, আর শব্দ দুটি স্থায়ী হয়। তাঁর মূল কথা ছিল: কোনোটিই স্বাভাবিকভাবে শ্রেষ্ঠ নয়, শুধু একমত হওয়াটা জরুরি।

Little-endian-এর একটি ব্যবহারিক সুবিধা ছোট CPU-তে স্পষ্ট। 8085-এর মতো ৮ বিটের CPU বহু-byte যোগ করে ছোট byte থেকে শুরু করে, কারণ carry নিচ থেকে ওপরে যায়। ছোট byte ছোট ঠিকানায় থাকলে CPU ঠিকানা বাড়াতে বাড়াতে byte-গুলো সেই ক্রমেই পায়, যেমন এই পর্বের BCD দামের যোগে পয়সার byte আগে। আরেকটি সুবিধা: একটি ৩২ বিটের মানকে ৮ বা ১৬ বিটের হিসেবে পড়তে চাইলে একই ঠিকানা থেকে পড়লেই হয়। Intel-এর 8080/8085 আর 8086 little-endian, আর PC-র বিশাল সাফল্যের পর সফটওয়্যার আর tool-এর জগৎ সেদিকে ঝুঁকেছে। ARM দুই ক্রমই সমর্থন করতে পারে, তবে বাস্তবে প্রায় সব ARM সিস্টেম little-endian; RISC-V নকশাতেই little-endian.

Network-এর ক্রম ঠিক হয়েছিল আগে, ১৯৭০ আর ৮০-এর দশকের Internet protocol-এ, যেখানে মানুষের পড়ার ক্রমের সঙ্গে মিলিয়ে বড় byte আগে পাঠানো স্বাভাবিক মনে হয়েছিল, আর তখনকার অনেক বড় কম্পিউটার big-endian ছিল। একবার standard হয়ে গেলে বদলানো অসম্ভব, তাই আজ TCP/IP, MQTT-এর দুই byte-এর দৈর্ঘ্য আর বহু sensor-এর data big-endian. ফল: প্রায় প্রতিটি little-endian firmware-কে সীমানায় byte উল্টাতে হয়। খরচ সামান্য, Cortex-M-এ একটি rev, কিন্তু ভুলে গেলে সংখ্যা সম্পূর্ণ ভুল হয়, যেমন stepper-এর 25605.

মূল উপলব্ধি: Byte-ক্রম একটি চুক্তি, প্রকৃতির নিয়ম নয়; firmware-এর নিয়ম হলো সীমানায় সবসময় স্পষ্টভাবে byte ধরে জোড়া লাগানো বা ভাঙা।

প্র ০৪Cortex-M4F-এর মতো chip-এ floating-point hardware থাকার পরেও firmware-এ কেন প্রায়ই fixed-point ব্যবহার হয়? কখন float-ই ভালো?

প্রথম কারণ টাকা। দশমিক ভগ্নাংশ যেমন 0.10 টাকা binary float-এ হুবহু রাখা যায় না; float-এ অনেকবার যোগ করলে ছোট ছোট ভুল জমে, আর দোকানের হিসাবে এক পয়সার গরমিলও গ্রহণযোগ্য নয়। পয়সায় integer রাখলে যোগ-বিয়োগ নির্ভুল, শুধু গুণ-ভাগের পরে গোল করার নিয়ম স্পষ্ট করে লিখতে হয়, যেমন স্কেলের সূত্রে + 500. দ্বিতীয় কারণ data নিজেই: ADC দেয় integer count, তাপমাত্রার sensor দেয় ১/১৬ °C-এর integer. এগুলো স্বভাবতই fixed-point, আর float-এ নিলে নতুন কোনো নির্ভুলতা আসে না।

তৃতীয় কারণ hardware-এর পরিবার। একই firmware প্রায়ই FPU ছাড়া সস্তা chip-এও চলে (Cortex-M0, M3), যেখানে float software library-তে চলে, অনেক ধীর আর code-এর আকার বাড়ায়। চতুর্থ কারণ interrupt: FPU থাকলে exception-এর সময় floating-point register-ও রাখতে হতে পারে। Cortex-M4F এই খরচ কমাতে “lazy stacking” ব্যবহার করে, তবু ISR-এ float ব্যবহার করলে latency আর stack-এর হিসাব জটিল হয়। পঞ্চম কারণ নির্ধারণযোগ্যতা: integer হিসাব যেকোনো compiler আর chip-এ বিট ধরে একই ফল দেয়, তাই host-এ unit test আর device-এর ফল হুবহু মেলে।

তবে float-এর জায়গাও আছে। যেখানে মানের পরিসর বিশাল (খুব ছোট থেকে খুব বড়), যেমন control loop-এর কিছু অংশ, filter-এর মধ্যবর্তী মান বা sensor fusion-এর matrix, সেখানে fixed-point-এ scale বাছাই আর overflow পাহারা দেওয়া কঠিন আর ভুলপ্রবণ। FPU থাকলে float সেখানে কোড সহজ করে আর ভুল কমায়। অনেক নকশায় তাই মিশ্র পথ: সীমানায় (ADC, দাম, protocol) integer, আর মাঝের জটিল গণিতে float. পর্ব ৪০-এ দুই পথের তুলনা হবে।

মূল উপলব্ধি: Fixed-point বেছে নেওয়া হয় নির্ভুলতা, বহনযোগ্যতা আর নির্ধারণযোগ্যতার জন্য; float বেছে নেওয়া হয় বড় পরিসর আর সরল কোডের জন্য, যখন hardware তা সস্তায় দেয়।

প্র ০৫ছোট একটি সংখ্যার রূপান্তরের ভুল কি বড় দুর্ঘটনা ঘটাতে পারে? দুটি পরিচিত ঘটনা থেকে firmware লেখক কী শিখবেন?

১৯৯৬ সালের জুনে Ariane 5 রকেটের প্রথম উড্ডয়ন কয়েক দশ সেকেন্ডের মধ্যে ধ্বংস হয়। তদন্ত কমিটির প্রতিবেদন অনুযায়ী inertial reference system-এর software একটি ৬৪ বিটের floating-point মানকে ১৬ বিটের signed integer-এ রূপান্তর করতে গিয়েছিল। Ariane 4-এর জন্য লেখা এই কোডে মানটি সবসময় সীমার ভেতরে থাকত, কিন্তু নতুন রকেটের গতিপথে মান অনেক বড় হলো। রূপান্তর ব্যর্থ হলো, ব্যতিক্রম ধরা হয়নি, যন্ত্র বন্ধ হলো, আর একই software-এর দ্বিতীয় যন্ত্রটিও একই কারণে আগেই থেমে ছিল। বিষয়টি ঠিক এই পর্বের ১৬ বিটের দামের ফাঁদের মতো: পুরোনো পরিবেশে “নিশ্চয়ই আঁটবে” ধরে নেওয়া, নতুন পরিবেশে মিথ্যা প্রমাণিত।

দ্বিতীয় ঘটনা ১৯৯১ সালের উপসাগরীয় যুদ্ধের Patriot ক্ষেপণাস্ত্র-প্রতিরক্ষা। মার্কিন সরকারের হিসাব-নিরীক্ষা দপ্তরের (GAO) ১৯৯২ সালের প্রতিবেদন অনুযায়ী system সময় গুনত দশমাংশ সেকেন্ডে, আর ০.১ সংখ্যাটি একটি ২৪ বিটের fixed-point register-এ রাখা হতো। ০.১ binary-তে অসীম ভগ্নাংশ, তাই কেটে রাখা মানে প্রতিটি tick-এ সামান্য ভুল। প্রায় ১০০ ঘণ্টা একটানা চলার পরে জমা ভুল দাঁড়ায় প্রায় এক-তৃতীয়াংশ সেকেন্ড, যা দ্রুতগামী লক্ষ্যের অবস্থান অনেক দূরে সরিয়ে দেয়। ফলে একটি আক্রমণ ঠেকানো যায়নি, আর মানুষের প্রাণ যায়। এটি fixed-point-এর একটি শিক্ষা: scale-এ হুবহু না আঁটা ধ্রুবক জমতে জমতে বড় হয়।

Firmware লেখকের জন্য শিক্ষা কয়েকটি। এক, প্রতিটি সংকীর্ণ রূপান্তরের (৩২ থেকে ১৬ বিট, float থেকে integer) পাশে সীমার যুক্তি লিখুন, আর সম্ভব হলে পরীক্ষা বা saturation বসান। দুই, পুরোনো কোড নতুন hardware বা নতুন পরিসরে নেওয়ার সময় সব অনুমান আবার যাচাই করুন। তিন, দীর্ঘ সময় চলা যন্ত্রে জমা ভুল আর counter-এর wrap হিসাব করুন: বাজারঘরের cold room মাসের পর মাস চলবে। চার, যেখানে সম্ভব, ধ্রুবক এমন এককে রাখুন যা হুবহু আঁটে, যেমন ১/১৬ °C বা পয়সা।

মূল উপলব্ধি: সংখ্যার রূপ বদলের প্রতিটি জায়গা একটি অনুমান বহন করে; firmware-এর নিরাপত্তা নির্ভর করে সেই অনুমান লিখে রাখা আর পরীক্ষা করার ওপর।

অনুশীলন

প্রথমে নিজে হিসাব করুন বা লিখুন, তারপর উত্তর খুলুন। প্রতিটি উত্তর চালিয়ে যাচাই করা।

  1. নকশা ও বাস্তবায়ন — দুই byte থেকে তাপমাত্রা: একটি C function int32_t tmp_to_centi(uint8_t msb, uint8_t lsb) লিখুন, যা cold room sensor-এর দুটি byte (বড়টি আগে) থেকে শতাংশ °C ফেরত দেয়, float ছাড়া, যেকোনো endianness-এর CPU-তে একই ফল। তারপর পাঁচটি জোড়ার ফল বলুন: (0x04, 0x00), (0xFF, 0x80), (0xE7, 0x00), (0x7F, 0xF0), (0x80, 0x00).
    int32_t tmp_to_centi(uint8_t msb, uint8_t lsb)
    {
        uint16_t word = (uint16_t)((msb << 8) | lsb);   /* byte ধরে জোড়া: endianness-মুক্ত */
        int32_t t16 = (int32_t)(int16_t)word >> 4;     /* sign extension, তারপর arithmetic shift */
        return t16 * 25 / 4;                           /* 1/16 C -> 1/100 C */
    }

    ফল: 0x0400 → t16 = 64 → 400 (৪.০০ °C); 0xFF80 → −8 → −50; 0xE700 → −400 → −2500 (−২৫.০০ °C); 0x7FF0 → 2047 → 12793 (সবচেয়ে বড় মান, ১২৭.৯৩৭৫ °C, শতাংশে কেটে 12793); 0x8000 → −2048 → −12800 (সবচেয়ে ছোট, −১২৮ °C). প্রথম তিনটি বাজারঘর board-এর সত্যিকারের run আর README-র সঙ্গে মেলে; পাঁচটিই লেখকের lab-এ একই সূত্রে চালিয়ে যাচাই করা। msb << 8-এ msb আগে int-এ ওঠে, তাই ১৬ বিটের int-এর CPU-তেও 0xFF << 8 = 0xFF00 আঁটে; তবু (uint16_t) cast লিখে রাখা ভালো অভ্যাস।

  2. ভুল খুঁজুন — দামের হিসাব: একজন স্কেলের firmware একটি 8-বিট AVR-এ নিয়েছেন। কোড: uint16_t net_g = 1250; uint16_t price = (net_g * 6550 + 500) / 1000;. Display-এ আসে 0.61 টাকা। ভুল কোথায়, আর ঠিক কোড কী? Cortex-M-এ একই কোড কেন ঠিক চলে?

    AVR-এ int ১৬ বিট, তাই net_g * 6550 হিসাব হয় ১৬ বিটে (uint16_t উঠে যায় unsigned int-এ, কারণ ১৬ বিটের int সব uint16_t মান ধরতে পারে না)। 1250 × 6550 + 500 = 8,188,000, যার 65536-এর ভাগশেষ 61536; ১০০০ দিয়ে ভাগে 61 পয়সা. এই পর্বের সত্যিকারের Clang run-এ AVR target ঠিক 61 দিয়েছে। Cortex-M-এ int ৩২ বিট, তাই গুণফল আঁটে আর ফল 8188. আরেকটি সতর্কতা: ফলের দাম এখন uint16_t-এ আঁটে (৫০০০ g-এ 32750 পয়সা), কিন্তু দর বা সীমা বাড়লে সেটিও ভাঙতে পারে, তাই দামের type-ও uint32_t রাখা নিরাপদ। ঠিক কোড: uint32_t price = ((uint32_t)net_g * 6550u + 500u) / 1000u;. ৫০০০ g-এ মাঝের ফল 32,750,500, ৩২ বিটে আঁটে।

  3. আগে বলুন, তারপর চালান — 8085-এর flag: MVI A,9CH, ADI 64H, SUI 01H, HLT. প্রতিটি হিসাবের পরে A আর S Z AC P CY কী হবে? Signed অর্থে প্রথম যোগে overflow হয়েছে কি?

    ADI 64H-এর পরে: 9CH + 64H = 100H, তাই A = 00H, S = 0, Z = 1, AC = 1 (C + 4 = 16, নিচের nibble থেকে carry), P = 1 (শূন্যটি 1, জোড়), CY = 1. Signed অর্থে −100 + 100 = 0, ঠিক: চিহ্ন দুটি আলাদা, তাই overflow অসম্ভব; CY = 1 শুধু unsigned অর্থে (156 + 100 = 256) সীমা পেরোনো বলে। SUI 01H-এর পরে: 00H − 01H = FFH, S = 1, Z = 0, AC = 0 (Spec decision 4: 0 + E + 1 = F, বিট ৩ থেকে carry নেই), P = 1 (আটটি 1, জোড়), CY = 1 (borrow). কোর্সের simulator-এর trace একই মান দেয়: শেষে Flags: S=1 Z=0 AC=0 P=1 CY=1 (F=85H), মোট ২৬ T-state.

  4. হিসাব — একটি register ভেঙে পড়া: বাজারঘর board-এর SCB CPUID register পড়লে আসে 0x412FC231 (README-র memory map). ARMv7-M Architecture Reference Manual অনুযায়ী field: বিট ৩১–২৪ Implementer, ২৩–২০ Variant, ১৯–১৬ Architecture, ১৫–৪ PartNo, ৩–০ Revision. প্রতিটি field-এর মান কী, আর এটি কোন core-এর কোন revision নির্দেশ করে?

    Hex-কে nibble-এ ভাঙুন: 41 2 F C23 1. Implementer = 0x41, ASCII-তে 'A', অর্থাৎ ARM. Variant = 2. Architecture = 0xF (ARMv7-M-এ এই মান নির্দিষ্ট). PartNo = 0xC23, যা Cortex-M3-এর সংখ্যা. Revision = 1. ARM-এর প্রথায় variant আর revision মিলে “r2p1”: Cortex-M3 r2p1. লেখকের lab-এ (c >> 24), (c >> 20) & 0xF, (c >> 16) & 0xF, (c >> 4) & 0xFFF, c & 0xF চালিয়ে একই মান পাওয়া গেছে: 0x41 2 0xf 0xc23 1. মনে রাখবেন, বাজারঘর board virtual; এই মান সে Cortex-M3-এর আদলে ফেরত দেয়।

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

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

ক্রম১২ বিটের two's complement তাপমাত্রা sensor (বড় byte আগে, word-এর বাঁয়ে বসানো) থেকে display পর্যন্ত ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. Bus থেকে বড় byte, তারপর ছোট byte পড়া
  2. (msb << 8) | lsb দিয়ে ১৬ বিটের word বানানো
  3. Word-কে int16_t হিসেবে ধরে ৩২ বিটে sign extension
  4. Arithmetic shift-এ ৪ ঘর ডানে: ১/১৬ °C-এর একক
  5. × 25 ÷ 4 দিয়ে শতাংশ °C-এ নেওয়া
  6. দুই দশমিক ঘরসহ display বা UART-এ ছাপা

8085-এ MVI A,7FH তারপর ADI 01H চলার পরে কোন কথাটি ঠিক?

  • CY = 1, কারণ ফল ঋণাত্মক হয়ে গেছে
  • Overflow flag = 1
  • A = 80H, S = 1, CY = 0; signed overflow হয়েছে কিন্তু 8085-এর কোনো flag তা দেখায় না
  • A = 80H, Z = 1

একটি sensor-এর ১৬ বিটের word 0xFF80, যেখানে মান ১২ বিটের two's complement, বাঁয়ে বসানো, প্রতি ধাপ 0.0625 °C. C-তে uint16_t raw-এ রাখা। raw >> 4 লিখলে কী পাওয়া যায়?

  • −8, অর্থাৎ −0.50 °C
  • 4088, অর্থাৎ ভুলভাবে 255.50 °C
  • −128
  • Compile error, কারণ ঋণাত্মক সংখ্যা shift করা যায় না

8085-এ A = 75H আর B = 48H (দুটিই packed BCD). ADD B তারপর DAA চলার পরে A আর CY কী?

  • A = BDH, CY = 0
  • A = C3H, CY = 0
  • A = 123H, CY = 0
  • A = 23H, CY = 1

একটি little-endian CPU ঠিকানা 2050H থেকে ১৬ বিটের মান 0564H (দশমিকে 1380) রাখল। Memory-তে 2050H আর 2051H-এ কী থাকবে?

  • 2050H = 64H, 2051H = 05H
  • 2050H = 05H, 2051H = 64H
  • 2050H = 46H, 2051H = 50H
  • 2050H = 64H, 2051H = 00H

ARM Cortex-M-এ subs r0, r1, r2 চলল, যেখানে r1 = 5 আর r2 = 7 (unsigned). APSR-এর C flag কী হবে, আর কেন?

  • C = 1, কারণ borrow হয়েছে
  • C = 0, কারণ ARM-এ বিয়োগের পরে C = 1 মানে borrow হয়নি
  • C অনির্দিষ্ট থাকে
  • C বদলায় না, শুধু V = 1 হয়

একটি স্কেলের দাম হিসাব হয় পয়সায়: (net_g * 6550 + 500) / 1000. ৫০০০ g পর্যন্ত ওজনের জন্য মাঝের গুণফল নিরাপদে রাখতে সবচেয়ে ছোট কোন unsigned মাপ যথেষ্ট?

  • ১৬ বিট
  • ২৪ বিট
  • ৩২ বিট
  • ৬৪ বিট

শব্দকোষ

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

মনে রাখুন

  1. Hex = nibble: প্রতিটি hex অঙ্ক ৪ বিট; register-এর মান nibble-এ ভেঙে datasheet-এর field ধরে পড়ুন (0x60 = বিট ৫ আর ৬).
  2. বিটের অর্থ type দেয়: 0xFF80 = 65408 বা −128; sensor-এর signed data-তে sign extension আর arithmetic shift, না হলে মিথ্যা alarm.
  3. CY আর overflow আলাদা: CY = unsigned সীমা, V/OF = signed সীমা। 8085-এ V নেই, 8086-এ OF, ARM-এ V; আর ARM-এ বিয়োগের C = 1 মানে borrow হয়নি।
  4. BCD আর DAA: nibble-প্রতি একটি দশমিক অঙ্ক; binary যোগের পরে DAA 06H আর/বা 60H যোগ করে সংশোধন করে; display-এ nibble সরাসরি segment টেবিলের index.
  5. Endianness আর fixed-point: 8085, 8086, Cortex-M little-endian, network আর অনেক sensor big-endian; ভগ্নাংশ integer-এ নির্দিষ্ট এককে, আর প্রতিটি গুণের সবচেয়ে বড় ফল type-এ আঁটে কি না, আগে হিসাব।

পরের পর্বে: পর্ব ০৬ (কোর্সের lab — simulator, cross-compiler, emulator আর আসল board ছাড়া কাজ). এই পর্বে যে tool-গুলো থেকে আউটপুট এসেছে, 8085 simulator, NASM আর Unicorn, বাজারঘর board আর Clang, সেগুলো কী করে, কী করে না, আর নিজের কম্পিউটারে অনুশীলনের জন্য কোন free tool আছে।

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

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