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

কোর্সের lab — simulator, cross-compiler, emulator আর আসল board ছাড়া কাজ

The Course Lab — Simulators, Cross-Compilers, Emulators and Working Without a Real Board

Taught in Bangla, this lesson tours the five tools behind every output in the course. A program is assembled, run and traced in the course's 8085 simulator (17 instructions, 117 T-states), 8086 code is assembled with NASM and run on Unicorn, blink firmware compiled with Clang runs on the virtual BG-M3 Cortex-M3 board, rtos_sim demonstrates priority inversion, and a local MQTT demo runs on the same machine. Each tool's known limits are stated, with the path to a trainer kit or real board.

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

  • Simulator, emulator, cross-compiler আর virtual board-এর পার্থক্য, আর কোনটি কোন প্রশ্নের উত্তর দিতে পারে
  • 8085 simulator-এ একটি program assemble করা, চালানো আর তার trace লাইন ধরে ধরে পড়া
  • NASM আর Unicorn-এ 8086 কোড চালানো, আর আসল 8086-এর সঙ্গে এর চারটি জানা পার্থক্য
  • বাজারঘর board-এর memory map, firmware কীভাবে Clang-এ compile হয়ে চলে, আর তার log-এর সময় কীভাবে হিসাব হয়
  • RTOS simulator আর local MQTT demo-র কাজ ও সীমা, আর নিজের কম্পিউটারের free tool-এ বা আসল board-এ একই ধরনের কাজ করার পথ

১ · আসল board ছাড়া embedded শেখা — lab-এর পাঁচটি tool

গাড়ি চালানো শিখতে প্রথম দিনেই কেউ ঢাকার মহাখালী মোড়ে নামেন না। আগে ড্রাইভিং স্কুলের ফাঁকা মাঠ: সেখানে স্টিয়ারিং, ব্রেক আর গিয়ার আলাদা করে বোঝা যায়, ভুল করলে কারও ক্ষতি হয় না। কিন্তু মাঠে রিকশা, বাস আর হঠাৎ রাস্তা পার হওয়া মানুষ নেই। মাঠে শেখা দক্ষতা আসল রাস্তায় কাজে লাগে, তবে রাস্তার নিজস্ব কিছু শিক্ষা থাকে। এই কোর্সের lab ঠিক সেই মাঠ।

এই কোর্সে কোনো আসল board লাগবে না। Lab-এর সব কাজ চলে একটি সাধারণ কম্পিউটারের software-এ, আর আপনি কোড চালান পাতার ভেতরেই। কিন্তু “software-এ চালানো” কয়েক রকমের হতে পারে, আর পার্থক্যগুলো জানা জরুরি:

Simulator

একটি যন্ত্রের আচরণ একটি model দিয়ে নকল করে। Simulator শুধু ততটুকু দেখায়, যতটুকু model-এ লেখা আছে। কোর্সের 8085 tool একটি instruction set simulator: প্রতিটি নির্দেশের পরে register, flag আর T-state.

sim8085, rtos_sim

Emulator

অন্য একটি CPU-র আসল machine code নির্দেশ ধরে চালায়। Emulator-এ আপনার program-এর byte-গুলোই চলে, নকল হিসাব নয়। কোর্সে Unicorn 8086 আর ARM Cortex-M3-এর কোড চালায়।

run8086, board

Cross-compiler

আপনার x86 বা ARM ল্যাপটপে চলে, কিন্তু অন্য CPU-র জন্য কোড বানায়। এই cross-compiler হলো Clang, যা Cortex-M-এর Thumb কোড তৈরি করে।

Clang 22.1.8

Virtual board

Emulator-এর CPU-র চারপাশে Python-এ লেখা নকল peripheral: GPIO, timer, UART, ADC, temperature sensor, watchdog. এটি কোনো আসল পণ্য নয়; আসল Cortex-M chip-এর আদলে তৈরি কোর্সের নিজস্ব শিক্ষণ-board.

BG-M3

এর সঙ্গে আছে একটি assembler (লেখা নির্দেশকে byte-এ অনুবাদ করার program) আর একটি linker (কয়েকটি অংশ জুড়ে একটি পূর্ণ program বানায়)। এরা মিলে একটি toolchain. নিচের ছবিতে পুরো lab এক নজরে দেখুন: বাঁয়ে কী লেখা হয়, মাঝে কোন tool চলে, ডানে কী আউটপুট আসে।

ছবি ৬.১ — কোর্সের lab: পাঁচটি পথ, একটি কম্পিউটার

বাঁয়ে input, মাঝে tool, ডানে আউটপুট; সবকিছু lab-এর একটি কম্পিউটারে

কোর্সের lab-এর পাঁচটি tool আর পাতার ভেতরের runner lab-এর কম্পিউটার · Python 3.13 input tool আউটপুট .asm 8085 sim8085.py assembler + simulator register, flag T-state .asm 8086 NASM → run8086.py Unicorn (386-শ্রেণি) লেখা, register সময় গোনে না .c firmware Clang → board.py virtual Cortex-M3 ms-সহ log UART, GPIO .json task rtos_sim.py tick ধরে scheduler Gantt chart response client paho mqtt_demo.py broker, 127.0.0.1 packet log message পাতার ভেতরে (কিছু বসাতে হয় না) Python: ব্রাউজারের Pyodide · JavaScript C: Wandbox-এর আসল compiler, শুধু আউটপুট

প্রতিটি tool reference lab-এর README-তে নম্বর দেওয়া নিয়মে বাঁধা, যার নাম “Spec decision”. এই পর্বে যখন লেখা থাকবে “Spec decision 17”, তখন বুঝবেন সেটি virtual board-এর সময়ের নিয়ম; নিয়মগুলো চল্লিশটি (8085: ১–১২, 8086: ১৩–১৬, board: ১৭–৩১, RTOS: ৩২–৩৬, IoT: ৩৭–৪০)। সব tool deterministic: একই input দিলে প্রতিবার হুবহু একই আউটপুট আসে, তাই এই পাতায় ছাপা আউটপুট একবারের কাকতাল নয়, স্থির রেফারেন্স।

মূল ধারণা

একটি tool-কে বিশ্বাস করার আগে তিনটি প্রশ্ন করুন: (১) এটি কী নকল করে? (২) কী নকল করে না? (৩) তার ফল কীভাবে অন্য উপায়ে যাচাই করা যায়? এই পর্বের প্রতিটি অংশ এই তিন প্রশ্নের উত্তর দেয়। আউটপুটের লেবেলও তিন রকম: “সত্যিকারের run” মানে tool চালিয়ে পাওয়া; “উদাহরণ” মানে চালানো হয়নি; “নমুনা আউটপুট” মানে হাতে লেখা আনুমানিক রূপ।

২ · 8085 simulator — লেখা থেকে byte, byte থেকে ফল

বাজারঘরের একজন কর্মচারী তিনটি ব্যাগ ওজন করলেন: 500 g, 1000 g আর 2000 g. 8085-এর ৮-বিটের হিসাবে এগুলো 100 g-এর এককে রাখা যাক: 05H, 0AH আর 14H. নিচের program তিনটি সংখ্যা যোগ করে মোট 2053H-এ রাখে। (8085 আর 8086-এর পর্বে hex লেখা হয় Intel-এর রীতিতে, শেষে H; C আর ARM অংশে সামনে 0x.)

; sum3.asm - add three bag weights (in 100 g units) at 2050H..2052H, total at 2053H
;@set 2050H 05H,0AH,14H
;@show 2050H 4
        ORG 2000H
START:  LXI H,2050H     ; HL -> first weight
        MVI C,03H       ; three bags
        XRA A           ; A = 0, flags cleared
LOOP:   ADD M           ; A <- A + [HL]
        INX H           ; next bag
        DCR C           ; one bag fewer
        JNZ LOOP        ; repeat until C = 0
        STA 2053H       ; store the total
        HLT
        END START

দুটি লাইন CPU-র জন্য নয়: ;@set আর ;@show. এরা মন্তব্যের ভেতরে লেখা simulator-এর নির্দেশ (pragma): চালানোর আগে 2050H থেকে তিনটি byte বসানো, আর শেষে 2050H থেকে চারটি byte দেখানো (Spec decision 10). ফলে ফাইলটি নিজেই সম্পূর্ণ: কাউকে আলাদা করে বলতে হয় না data কোথায়। sim8085.py-এর চারটি command আছে: asm (listing), run (শেষ ফল), trace (প্রতিটি নির্দেশের পরের অবস্থা) আর dis (byte থেকে আবার নির্দেশ, অর্থাৎ disassembler). নিচের stepper-এ পুরো পথটি দেখুন।

  1. উৎসsum3.asmলেখা
  2. pass 1labelঠিকানা গোনা
  3. pass 2byteopcode বসানো
  4. load;@setমেমরি সাজানো
  5. runfetch–executeT-state গোনা
  6. ফল2053Hregister, flag
sum3.asm৯টি নির্দেশ, ২টি label
START: LXI H,2050H · MVI C,03H · XRA A
LOOP:  ADD M · INX H · DCR C · JNZ LOOP
       STA 2053H · HLT
;@set 2050H 05H,0AH,14H
pass 1symbol table
ORG 2000H থেকে আকার যোগ:
LXI 3 + MVI 2 + XRA 1 = 6 byte
Symbols:
  LOOP         2006H
  START        2000H
pass 2asm listing (অংশ)
2000  21 50 20   LXI H,2050H
2003  0E 03      MVI C,03H
2005  AF         XRA A
2006  86         ADD M
2009  C2 06 20   JNZ LOOP
Start: 2000H   Bytes: 16
load৬৪ KiB, শুরুতে সব 00H
2000H..200FH : program-এর ১৬ byte
2050H: 05 0A 14   (;@set থেকে)
2053H: 00
A–L = 00H, SP = 0000H, PC = 2000H
runনির্দেশ ধরে
প্রতিটি নির্দেশ: fetch → decode → execute
T-state: Intel-এর টেবিল থেকে
JNZ: নেওয়া হলে 10, না নিলে 7
লুপ ৩ বার → মোট ১৭টি নির্দেশ
python -B sim8085.py run sum3.asmসত্যিকারের run
A=23 … H=20 L=53 SP=0000 PC=2010
Flags: S=0 Z=1 AC=1 P=1 CY=0 (F=54H)
  2050H: 05 0A 14 23
Instructions: 17   T-states: 117
  1. উৎস ফাইল। আপনি লেখেন নির্দেশের নাম (mnemonic), label আর মন্তব্য। ORG 2000H বলে program কোন ঠিকানা থেকে বসবে, END START বলে কোথা থেকে চালানো শুরু হবে (Spec decision 6).
  2. প্রথম পাস: label-এর ঠিকানা। Assembler প্রতিটি নির্দেশের আকার যোগ করে এগোয়: 2000H থেকে ৩ + ২ + ১ = ৬ byte পরে LOOP, তাই LOOP = 2006H. দুই পাস থাকায় পরে লেখা label-এর দিকেও লাফ দেওয়া যায় (Spec decision 9).
  3. দ্বিতীয় পাস: byte বসানো। প্রতিটি নির্দেশ তার opcode আর data হয়। JNZ LOOP হয় C2 06 20: opcode C2, তারপর ঠিকানা 2006H-এর নিচের byte আগে (06), ওপরের byte পরে (20). মোট ১৬ byte.
  4. Load. Simulator ৬৪ KiB মেমরি সব 00H দিয়ে শুরু করে, program-এর byte আর ;@set-এর তিনটি ওজন বসায়। Register সব 00H, SP = 0000H; আসল 8085-এর reset শুধু PC আর interrupt-এর অবস্থা ঠিক করে, অন্য register-এর মান অনির্দিষ্ট থাকতে পারে; এখানে নিয়ম করে শূন্য (Spec decision 6).
  5. Run. প্রতিটি নির্দেশ fetch, decode আর execute হয়, আর তার T-state যোগ হয় Intel 8085 user's manual-এর টেবিল থেকে (Spec decision 2). শর্তযুক্ত JNZ লাফ দিলে ১০, না দিলে ৭ T-state. লুপ তিনবার ঘোরে, তাই মোট ১৭টি নির্দেশ চলে।
  6. ফল। 5 + 10 + 20 = 35 = 23H, অর্থাৎ 3500 g. মোট ১১৭টি T-state, 3 MHz-এ 117 ÷ 3 = 39 µs. Flag-এ Z = 1 কেন, যখন A = 23H শূন্য নয়? কারণ শেষ flag-বদলানো নির্দেশ ছিল DCR C (C = 0); STA আর HLT flag ছোঁয় না।

পুরো listing আর run-এর আউটপুট (সত্যিকারের run, sim8085.py, Python 3.13.5; listing থেকে মন্তব্যের কলাম আর লাইন নম্বর বাদ):

$ python -B sim8085.py asm sum3.asm
2000  21 50 20   START:  LXI H,2050H
2003  0E 03              MVI C,03H
2005  AF                 XRA A
2006  86         LOOP:   ADD M
2007  23                 INX H
2008  0D                 DCR C
2009  C2 06 20           JNZ LOOP
200C  32 53 20           STA 2053H
200F  76                 HLT
Symbols:
  LOOP         2006H
  START        2000H
Start: 2000H   Bytes: 16

$ python -B sim8085.py run sum3.asm
A=23 B=00 C=00 D=00 E=00 H=20 L=53 SP=0000 PC=2010
Flags: S=0 Z=1 AC=1 P=1 CY=0   (F=54H)
Memory 2050H..2053H:
  2050H: 05 0A 14 23
Instructions: 17   T-states: 117

F=54H হলো পুরো flag byte: Z (বিট 6, 40H) + AC (বিট 4, 10H) + P (বিট 2, 04H) = 54H. Simulator কখন থামে, আর ভুলে কী বলে, সেটিও জানা দরকার। দুটি ছোট ভুল-program চালানো হলো (সত্যিকারের run): একটিতে DB 08H দিয়ে একটি undocumented opcode রাখা, অন্যটিতে HLT ভুলে চিরকাল ঘোরা লুপ।

$ python -B sim8085.py run undoc.asm
runtime error: undocumented opcode 08H at 2002H
$ python -B sim8085.py run forever.asm --max-steps 1000
runtime error: stopped after 1000 instructions (no HLT reached?)

আসল 8085-এ দশটি undocumented opcode কিছু একটা করে; কয়েকটির আচরণ পরে অনেকে খুঁজে বের করেছেন। কিন্তু Intel সেগুলোর নিশ্চয়তা দেয়নি, তাই simulator সেগুলো চালায় না, থেমে যায় (Spec decision 1). আর স্বাভাবিক সীমা ১০ লাখ নির্দেশ (Spec decision 11), যাতে একটি ভুল লুপ কম্পিউটার আটকে না রাখে।

sim8085 যা করেযা করে না (সৎ সীমা)
২৪৬টি documented opcode, assembler আর disassembler (Spec decision 1, 9)undocumented opcode চালায় না, থামে
Intel-এর টেবিলের T-state, শর্তযুক্ত নির্দেশের দুই রকম সময় (Spec decision 2)wait state নেই; ধীর মেমরি থাকলে আসল সময় বেশি
S Z AC P CY flag, DAA, PUSH PSW (Spec decision 3–5)flag byte-এর অব্যবহৃত বিট D5, D3, D1 সবসময় 0; আসল chip-এ সেখানে অনথিভুক্ত মান থাকতে পারে
TRAP, RST7.5/6.5/5.5, INTR, SIM, RIM, সময় ধরে interrupt (Spec decision 7–8)pin-এর বৈদ্যুতিক আচরণ, ALE-এর তরঙ্গ, bus-এর তার নেই
আলাদা একটি 8080 emulator-এর সঙ্গে মিলিয়ে দেখা (Spec decision 12)RIM/SIM আর T-state সেই যাচাইয়ে নেই (8080-এ নেই বা আলাদা)

শেষ সারির যাচাইটিও আসল: crosscheck_8085.py PyPI-এর z80 package-এর স্বাধীন i8080 core-এর সঙ্গে হাজার হাজার এলোমেলো নির্দেশে register, মেমরি আর flag মেলায়। ছোট একটি run (সত্যিকারের run, z80 1.2.0, MIT):

$ python -B crosscheck_8085.py --single 2000 --streams 20
single-instruction cases: 2000 passed, 0 failed
random streams: 20 passed, 0 failed, 6485 instructions compared

পূর্ণ run-এ (README অনুযায়ী) ২৪ হাজার একক নির্দেশ আর ৩০০টি এলোমেলো ধারায় ৯৭ হাজারের বেশি নির্দেশ মেলানো হয়েছে, কোনো অমিল নেই। দুটি আলাদা মানুষের লেখা দুটি আলাদা program একই উত্তর দিলে ভুলের সম্ভাবনা অনেক কমে যায়; একে বলে differential testing.

৩ · Simulator-এর trace পড়া — প্রতিটি লাইন একটি নির্দেশের পরের ছবি

run শুধু শেষ ফল দেখায়। ভুল খুঁজতে দরকার instruction trace: প্রতিটি নির্দেশের পরে সব register, flag আর সময়। এটি অনেকটা ক্রিকেটের ball-by-ball স্কোরকার্ডের মতো: শুধু শেষ রান নয়, প্রতিটি বলের পরে কী বদলাল। trace-এর প্রতিটি লাইনের গঠন: ঠিকানা, byte, নির্দেশ, তারপর নির্দেশ শেষ হওয়ার পরের register আর flag, এই নির্দেশের T আর মোট T. প্রথম কয়েকটি লাইন (সত্যিকারের run; জায়গা বাঁচাতে B, D, E আর SP-এর কলাম বাদ, সবই 00 বা 0000):

$ python -B sim8085.py trace sum3.asm
2000  21 50 20  LXI H,2050H  A=00 C=00 H=20 L=50 PC=2003 S=0 Z=0 AC=0 P=0 CY=0  T=10 total=10
2003  0E 03     MVI C,03H    A=00 C=03 H=20 L=50 PC=2005 S=0 Z=0 AC=0 P=0 CY=0  T=7  total=17
2005  AF        XRA A        A=00 C=03 H=20 L=50 PC=2006 S=0 Z=1 AC=0 P=1 CY=0  T=4  total=21
2006  86        ADD M        A=05 C=03 H=20 L=50 PC=2007 S=0 Z=0 AC=0 P=1 CY=0  T=7  total=28
2007  23        INX H        A=05 C=03 H=20 L=51 PC=2008 S=0 Z=0 AC=0 P=1 CY=0  T=6  total=34
2008  0D        DCR C        A=05 C=02 H=20 L=51 PC=2009 S=0 Z=0 AC=1 P=0 CY=0  T=4  total=38
2009  C2 06 20  JNZ 2006H    A=05 C=02 H=20 L=51 PC=2006 S=0 Z=0 AC=1 P=0 CY=0  T=10 total=48
…

পুরো ১৭টি লাইন থেকে গুরুত্বপূর্ণ মুহূর্তগুলো stepper-এ সাজানো হলো। প্রতিটি ধাপের মান হুবহু trace থেকে নেওয়া।

2000LXI H,2050H2003MVI C,03H2005XRA A2006ADD M2007INX H2008DCR C2009JNZ LOOP200CSTA 2053H200FHLT
নির্দেশের পরে
A
C
L
Z
CY
PC
T
মোট T
[2053H]
  1. XRA A (মোট ২১)। A-কে নিজের সঙ্গে XOR করলে A = 00H. এটি MVI A,00H-এর চেয়ে এক byte ছোট আর ৩ T-state কম (৪ বনাম ৭), আর CY-কে 0 করে। Z = 1, কারণ ফল শূন্য।
  2. প্রথম ADD M (মোট ২৮)। M মানে HL যে ঠিকানা দেখায়, সেই ঘর: [2050H] = 05H. A = 00 + 05 = 05H. Z আবার 0. মেমরি থেকে পড়ায় ৭টি T-state.
  3. প্রথম DCR C (মোট ৩৮)। মাঝে INX H L-কে 51H করেছে (৬ T). এখন C = 03 থেকে 02. Z = 0, কারণ C শূন্য নয়। (Trace-এ AC = 1 দেখাবে: DCR-এ পুরোনো নিচের nibble 0 না হলে AC = 1, Spec decision 4.)
  4. JNZ লাফ দিল (মোট ৪৮)। Z = 0, তাই শর্ত সত্য: PC সরাসরি 2006H, অর্থাৎ LOOP-এ ফেরে। লাফ নেওয়ায় ১০টি T-state. লক্ষ করুন, এই লাইনে PC-র মান পরের নির্দেশের ঠিকানা, 200CH নয়।
  5. তৃতীয় ADD M (মোট ৮২)। দ্বিতীয় পাকে A হয়েছিল 0FH; এখন 0F + 14 = 23H. লুপের প্রতিটি পাক ৭ + ৬ + ৪ + ১০ = ২৭ T. CY এখনো 0, কারণ যোগফল 255 পেরোয়নি।
  6. শেষ DCR C (মোট ৯২)। C = 01 থেকে 00, তাই Z = 1. এই flag-ই ঠিক করবে পরের লাফ হবে কি না। L = 53H, অর্থাৎ HL চতুর্থ ঘরে (2053H) পৌঁছে গেছে।
  7. JNZ লাফ দিল না (মোট ৯৯)। Z = 1, শর্ত মিথ্যা, PC = 200CH, পরের নির্দেশে চলে যায়। না-নেওয়া লাফে মাত্র ৭টি T-state (Spec decision 2). এই কারণেই লুপের সময়ের সূত্রে শেষ পাক আলাদা।
  8. STA 2053H (মোট ১১২)। A = 23H মেমরির 2053H-এ লেখা হলো। ১৩টি T-state: opcode, ঠিকানার দুই byte, তারপর লেখা। Flag অপরিবর্তিত, তাই Z এখনো 1.
  9. HLT (মোট ১১৭)। CPU থামে, PC = 2010H. মোট T = 21 + 3 × 17 + 2 × 10 + 7 + 13 + 5 = 117. সাধারণভাবে N টি ব্যাগে T = 27N + 36; N = 3-এ 117. 3 MHz-এ 39 µs.

এবার একই trace নিজের ব্রাউজারে তৈরি করুন। নিচের Python কোড এই program-এর নয়টি opcode চেনে এমন একটি খুব ছোট 8085 emulator: সত্যিকারের byte পড়ে, লাফ দেয়, T-state গোনে। কোডটি আপনার ব্রাউজারে আসল CPython-এ চলে (Pyodide). এটি reference lab-এর sim8085.py-এর অতি ছোট রূপ; শুধু Z আর CY flag রাখে, S, AC আর P বাদ।

mem = bytearray(65536)                          # 64 KiB, all 00H
mem[0x2000:0x2010] = bytes([0x21, 0x50, 0x20, 0x0E, 0x03, 0xAF, 0x86, 0x23,
                            0x0D, 0xC2, 0x06, 0x20, 0x32, 0x53, 0x20, 0x76])
mem[0x2050:0x2053] = bytes([0x05, 0x0A, 0x14])  # ;@set 2050H 05H,0AH,14H
A = C = H = L = Z = CY = 0
PC, total = 0x2000, 0

def nxt():                                      # read one byte at PC
    global PC
    b = mem[PC]; PC += 1
    return b

while True:
    at, op = PC, nxt()
    if op == 0x21:   L, H = nxt(), nxt(); t, s = 10, f"LXI H,{H:02X}{L:02X}H"
    elif op == 0x0E: C = nxt(); t, s = 7, f"MVI C,{C:02X}H"
    elif op == 0xAF: A = CY = 0; Z = 1; t, s = 4, "XRA A"
    elif op == 0x86:
        r = A + mem[H << 8 | L]; CY, A = r >> 8, r & 0xFF
        Z = int(A == 0); t, s = 7, "ADD M"
    elif op == 0x23:
        hl = ((H << 8 | L) + 1) & 0xFFFF; H, L = hl >> 8, hl & 0xFF
        t, s = 6, "INX H"
    elif op == 0x0D: C = (C - 1) & 0xFF; Z = int(C == 0); t, s = 4, "DCR C"
    elif op == 0xC2:
        lo, hi = nxt(), nxt(); s = f"JNZ {hi:02X}{lo:02X}H"
        if Z: t = 7                             # not taken
        else: PC, t = hi << 8 | lo, 10          # taken
    elif op == 0x32:
        lo, hi = nxt(), nxt(); mem[hi << 8 | lo] = A; t, s = 13, f"STA {hi:02X}{lo:02X}H"
    elif op == 0x76: t, s = 5, "HLT"
    total += t
    print(f"{at:04X} {s:11} A={A:02X} C={C:02X} L={L:02X} Z={Z} CY={CY} T={t:<2} total={total}")
    if op == 0x76: break

আসল আউটপুট (ব্রাউজারের Python; প্রথম চারটি আর শেষ চারটি লাইন):

2000 LXI H,2050H A=00 C=00 L=50 Z=0 CY=0 T=10 total=10
2003 MVI C,03H   A=00 C=03 L=50 Z=0 CY=0 T=7  total=17
2005 XRA A       A=00 C=03 L=50 Z=1 CY=0 T=4  total=21
2006 ADD M       A=05 C=03 L=50 Z=0 CY=0 T=7  total=28
…
2008 DCR C       A=23 C=00 L=53 Z=1 CY=0 T=4  total=92
2009 JNZ 2006H   A=23 C=00 L=53 Z=1 CY=0 T=7  total=99
200C STA 2053H   A=23 C=00 L=53 Z=1 CY=0 T=13 total=112
200F HLT         A=23 C=00 L=53 Z=1 CY=0 T=5  total=117

সতেরোটি লাইনের প্রতিটি sim8085-এর trace-এর সঙ্গে A, C, L, Z, CY, T আর মোট T-তে হুবহু মেলে। এটি একটি ছোট differential test: দুটি আলাদা বাস্তবায়ন একই উত্তর দিল। JNZ শাখায় দেখুন, লাফ না নিলে PC এমনিতেই পরের নির্দেশে (200CH) থাকে, কারণ nxt() দুই byte পড়ে PC এগিয়ে রেখেছে। mem[0x2050:0x2053]-এর তিনটি সংখ্যা বদলে চালিয়ে দেখুন; যেমন 80H, 90H, F0H দিলে যোগফল 255 পেরোবে আর CY = 1 হবে।

৪ · 8086 — NASM দিয়ে assemble, Unicorn-এ চালানো

8086-এর জন্য কোর্স নিজের simulator লেখেনি। এর বদলে দুটি পরিচিত open-source tool: NASM (Netwide Assembler) উৎস লেখাকে আসল 8086 machine code-এ বদলায়, আর Unicorn সেই byte-গুলো একটি CPU emulator-এ চালায়। Unicorn তৈরি QEMU-র CPU অংশ থেকে। run8086.py দুটিকে জোড়ে আর একটি খুব ছোট DOS-এর নকল যোগ করে, যাতে program লেখা ছাপতে পারে।

        org 100h
        mov ah, 09h
        mov dx, msg
        int 21h                 ; print the $-terminated string at DS:DX
        mov ax, 4C00h
        int 21h                 ; exit, code 0
msg:    db 'Hello from 8086!', 13, 10, '$'
$ python -B run8086.py hello.asm --regs
Hello from 8086!
----
AX=4C00 BX=0000 CX=0000 DX=010C SI=0000 DI=0000 BP=0000 SP=FFFE CS=1000 DS=1000 ES=1000 SS=1000 IP=010C --I------
[exit code 0 via INT 21h/4Ch, 5 instructions]

(সত্যিকারের run: NASM 3.02, BSD-2-Clause; unicorn 2.1.4, binding BSD, engine GPLv2.) Program বসে 1000:0100h-এ, অর্থাৎ CS = 1000h, offset 0100h; ভৌত ঠিকানা 1000h × 10h + 0100h = 10100h. চারটি segment register একই 1000h, SP = FFFEh, আর IF flag চালু (শেষের --I------)। এই শুরুর অবস্থা Spec decision 13-এ লেখা; DOS-এর কোন কাজগুলো (INT 21h-এর 01h, 02h, 09h, 25h, 35h, 4Ch) নকল করা আছে, তা Spec decision 14-এ। --trace দিলে প্রতিটি নির্দেশ আর register দেখা যায়; একটি লাইন:

1000:0102  BA0C01   mov dx,0x10c   AX=0900 BX=0000 CX=0000 DX=010C … IP=0105 --I------

Assembler-এর সারিতে আরেকটি পাহারা আছে। প্রতিটি উৎসের শুরুতে cpu 8086 জুড়ে দেওয়া হয়, তাই 80186 বা পরের CPU-র নির্দেশ লিখলে NASM নিজেই আটকায়। push 1234h (immediate push, 80186 থেকে আছে) লিখে দেখা হলো (সত্যিকারের run):

$ python -B run8086.py imm186.asm
error: NASM failed:
imm186.asm:3: error: no instruction for this cpu level

Unicorn আসল 8086 নয় — চারটি জানা পার্থক্য

Unicorn ভেতরে আসলে 386-শ্রেণির একটি CPU-কে real mode-এ চালায়। বেশিরভাগ নির্দেশ 8086-এর মতোই আচরণ করে, কিন্তু চারটি জায়গায় নয় (Spec decision 15). প্রথমটি নিজে চালিয়ে দেখা হলো:

; pushsp.asm - what does PUSH SP store?
        org 100h
        mov ax, sp          ; AX = SP before the push
        push sp
        pop bx              ; BX = the value PUSH SP stored
        mov ax, 4C00h
        int 21h

$ python -B run8086.py pushsp.asm --regs
----
AX=4C00 BX=FFFE CX=0000 DX=0000 SI=0000 DI=0000 BP=0000 SP=FFFE CS=1000 DS=1000 ES=1000 SS=1000 IP=0109 --I------
[exit code 0 via INT 21h/4Ch, 5 instructions]

BX = FFFEh, অর্থাৎ push-এর আগের SP লেখা হয়েছে। Intel-এর নিজের manual (Intel 64 and IA-32 Software Developer's Manual-এর PUSH নির্দেশের বর্ণনা) অনুযায়ী 286 থেকে পরের CPU এটাই করে, কিন্তু আসল 8086 লেখে SP − 2-এর পরের মান, এখানে FFFCh. পরীক্ষার খাতায় 8086-এর উত্তর লিখবেন।

বিষয়আসল 8086Unicorn (386-শ্রেণি)
PUSH SPনতুন SP (SP − 2) লেখেপুরোনো SP লেখে
shift/rotate-এর count (CL)পুরো count মানেনিচের ৫ বিট নেয় (০–৩১)
PUSHF-এ FLAGS-এর বিট 12–1510
divide error-এর ফেরার ঠিকানাDIV-এর পরের নির্দেশDIV নিজেই
সময়প্রতিটি নির্দেশের clock সংখ্যা আছেকোনো সময় গোনা হয় না (Spec decision 16)

কোর্সের 8086 উদাহরণগুলো এই চারটি জায়গা এড়িয়ে লেখা, আর একটি test প্রতিটি পার্থক্যকে আটকে রাখে, যাতে Unicorn-এর নতুন version-এ আচরণ বদলালে সঙ্গে সঙ্গে ধরা পড়ে। 8086-এর timing (clock count) প্রশ্নের জন্য Intel-এর টেবিল আর হাতের হিসাব লাগবে; সেটি পর্ব ২১-এ (8086-এর minimum আর maximum mode, bus cycle আর 8088).

৫ · বাজারঘর board — virtual Cortex-M3-এ আসল firmware

কোর্সের সবচেয়ে বড় tool হলো “বাজারঘর board”, সংক্ষেপে BG-M3. আগেই স্পষ্ট করে বলি: এটি কোনো আসল পণ্য নয়। এটি একটি শিক্ষণ-model: Unicorn-এর Cortex-M3 CPU model, তার চারপাশে Python-এ লেখা সরল peripheral, যাদের register-এর নাম STM32-এর রীতি মেনে রাখা, যাতে শেখা দক্ষতা আসল chip-এ কাজে লাগে। কিন্তু ঠিকানা আর বিট সরলীকৃত। CPU যা চালায়, তা আসল: C-তে লেখা firmware, Clang দিয়ে ARMv7-M-এর Thumb কোডে compile করা।

ঠিকানাকী আছে
0x08000000Flash, 128 KiB: শুরুতেই vector table, তারপর কোড (শুধু পড়া আর চালানো)
0x20000000SRAM, 20 KiB; stack নামে 0x20005000 থেকে নিচে
0x40003000IWDG watchdog
0x40004400UART (SR, DR, BRR, CR1)
0x40005400I2C-এর মতো bus: temperature sensor, ঠিকানা 0x48
0x40010400EXTI line 0 (button-এর edge)
0x40010800GPIOA: PA0 button, PA5 সবুজ LED, PA6 alarm
0x40012400ADC1, ১২-বিট, channel 0 = load cell
0x40021000RCC: reset-এর কারণ (CSR)
0x400FF000SIMCTRL: শুধু emulator-এ, run থামানোর জন্য; আসল chip-এ নেই (Spec decision 29)
0xE000E010SysTick timer (আসল ARM ঠিকানা)
0xE000E100NVIC; 0xE000ED00-এ SCB

এই টেবিলই board-এর memory map. প্রতিটি peripheral memory-mapped: একটি ঠিকানায় লেখা মানে একটি hardware register-এ লেখা। যেমন 0x4001080C হলো GPIOA-র ODR (output data register); এর বিট 5-এ 1 লিখলে PA5-এর LED জ্বলে। এই map-এর পূর্ণ ব্যাখ্যা পর্ব ৩১-এ (Memory map আর linker script).

প্রথম firmware: blink

blink.c প্রতি 1 ms-এ একটি SysTick interrupt নেয়, আর প্রতি 500 ms-এ GPIO-র LED উল্টায়; মাঝের সময় CPU WFI নির্দেশে ঘুমায়। মূল অংশ (reference lab-এর firmware/blink.c):

static volatile uint32_t ms_ticks;          /* changed by the ISR: volatile */

void SysTick_Handler(void)
{
    ms_ticks++;
}

int main(void)
{
    GPIOA->DIR |= 1u << LED_PIN;                     /* PA5 = output */
    SysTick->LOAD = SystemCoreClock / 1000u - 1u;   /* 8 000 000 / 1000 - 1 = 7999 */
    SysTick->VAL = 0;
    SysTick->CTRL = SysTick_CTRL_CLKSOURCE | SysTick_CTRL_TICKINT | SysTick_CTRL_ENABLE;

    for (int i = 0; i < 6; i++) {
        delay_ms(500);                               /* WFI until 500 ticks pass */
        GPIOA->ODR ^= 1u << LED_PIN;                 /* toggle */
    }
    board_exit(0);
}

এই কোড আপনার ল্যাপটপে চলবে না; এটি Cortex-M3-এর জন্য। কীভাবে লেখা থেকে চলা পর্যন্ত যায়, ধাপে ধাপে দেখুন। প্রতিটি panel-এর লেখা lab-এর আসল আউটপুট থেকে।

  1. C উৎসblink.c+ startup.c, bglib.c
  2. Clangthumbv7mcross-compile
  3. ld.lldblink.elf+ map file
  4. resetMSP, PCvector table
  5. mainLOAD=7999SysTick চালু
  6. LEDPA5500 ms পরপর
  7. শেষexit(0)cycle গোনা
python -B board.py build blink.cসত্যিকারের run
built blink.elf
(blink.c + startup.c + bglib.c,
 header: bazarghar.h)
clang -S … -O2Thumb assembly (অংশ)
SysTick_Handler:
    movw  r0, :lower16:ms_ticks
    movt  r0, :upper16:ms_ticks
    ldr   r1, [r0]
    adds  r1, #1
    str   r1, [r0]
    bx    lr
main: …  movw r2, #7999
blink.mapকোথায় কী বসল (অংশ)
8000000    60 .isr_vector
8000060   19c .text
8000061    10   SysTick_Handler
8000071   102   main
8000179    82   Reset_Handler
20000000    4 .bss  ms_ticks
board.py run blink.elf --trace 24প্রথম লাইন
[0.0000 ms] power-on reset (BG-M3, 8 MHz)
MSP = [0x08000000] = 0x20005000
PC  = [0x08000004] = 0x08000179
[0.0001 ms] trace PC=0x08000178 Reset_Handler+0x0
[0.0022 ms] trace PC=0x08000070 main+0x0
main-এর register লেখাC → ঠিকানা
GPIOA->DIR  (0x40010800) |= 1<<5
SysTick->LOAD (0xE000E014) = 7999
SysTick->CTRL (0xE000E010) = 7
তারপর WFI: CPU ঘুমায়
board.py run blink.elfসত্যিকারের run
[     0.0000 ms] power-on reset (…)
[   500.0054 ms] GPIO PA5 LED ON
[  1000.0054 ms] GPIO PA5 LED OFF
[  1500.0054 ms] GPIO PA5 LED ON
শেষ দুই লাইনসত্যিকারের run
[  3000.0054 ms] GPIO PA5 LED OFF
[  3000.0059 ms] exit(0) after
                 24000047 cycles
  1. C উৎস। board.py build আপনার ফাইলের সঙ্গে দুটি সাধারণ ফাইল জোড়ে: startup.c (vector table আর reset-এর কোড) আর bglib.c (UART-এ লেখা ছাপার সহায়ক)। Register-এর নাম আর ঠিকানা আসে bazarghar.h থেকে।
  2. Clang: cross-compile. Clang 22.1.8 (--target=thumbv7m-none-eabi -mcpu=cortex-m3 -O2) প্রতিটি C ফাইলকে Thumb machine code-এ বদলায়। ISR-টি মাত্র ছয়টি নির্দেশ: ঠিকানা আনা, পড়া, এক যোগ, লেখা, ফেরা। volatile থাকায় প্রতিবার আসলেই মেমরি থেকে পড়ে।
  3. Linker আর map. ld.lld linker script bazarghar.ld মেনে সব অংশ ঠিকানায় বসায়: 0x60 byte-এর vector table flash-এর শুরুতে, কোড তার পরে, আর ms_ticks SRAM-এর .bss-এ। ফল একটি ELF ফাইল আর একটি map file; flash-এ মোট 0x1FC = 508 byte, SRAM-এ ৪ byte.
  4. Reset. Board ELF-এর byte flash-এ বসায়। Cortex-M-এর নিয়মে CPU প্রথমে 0x08000000 থেকে stack-এর শুরু (MSP = 0x20005000) আর 0x08000004 থেকে reset handler-এর ঠিকানা পড়ে (Spec decision 18). ঠিকানার শেষ বিট 1 (0x08000179) মানে “Thumb কোড”; চলে 0x08000178 থেকে। Reset_Handler .data কপি আর .bss শূন্য করে main ডাকে।
  5. main: register-এ লেখা। DIR-এর বিট 5 = 1 করে PA5-কে output বানায়। SysTick-এর LOAD = 7999, কারণ period = LOAD + 1 = 8000 cycle = 1 ms at 8 MHz (Spec decision 22). CTRL = 4 + 2 + 1 = 7: clock source, interrupt আর চালু। তারপর WFI: board সময় সরাসরি পরের ঘটনায় নিয়ে যায় (Spec decision 21).
  6. প্রথম LED, 500.0054 ms-এ। ৫০০টি SysTick interrupt = 500 × 8000 = 40 লাখ cycle = ঠিক 500 ms. বাড়তি 0.0054 ms মানে প্রায় ৪৩টি cycle: reset থেকে SysTick চালু হওয়া পর্যন্ত নির্দেশগুলো। পরের সব পরিবর্তন ঠিক 500 ms পরপর, কারণ timer নিজে ঠিক তালে চলে।
  7. শেষ: 24000047 cycle. ছয়বার × 500 ms = 3000 ms = 2 কোটি ৪০ লাখ cycle, সঙ্গে ৪৭টি বাড়তি cycle শুরুর আর শেষের কোডের। মনে রাখুন, এখানে ১টি নির্দেশ = ১টি cycle (Spec decision 17); আসল Cortex-M3-এ সংখ্যাগুলো আলাদা হবে, কিন্তু ক্রম আর মান একই থাকবে।

Compiler আসলে কী বানাল, তা নিজে দেখা যায়। নিচে -S দিয়ে পাওয়া main-এর শুরুর অংশ (সত্যিকারের run, ziglang 0.17.1-এর Clang 22.1.8, MIT আর Apache-2.0 with LLVM exception):

$ python -m ziglang clang -S --target=thumbv7m-none-eabi -mcpu=cortex-m3 -mthumb -O2 \
      -ffreestanding -fno-sanitize=undefined blink.c -o blink.s
main:
	movw	r0, #2060        @ 0x080C
	movt	r0, #16385       @ 0x4001 -> r0 = 0x4001080C (GPIOA ODR)
	ldr	r1, [r0, #-12]   @ DIR is 12 bytes below ODR
	movw	r2, #7999
	orr	r1, r1, #32      @ 1 << 5
	str	r1, [r0, #-12]

(@-এর পরের মন্তব্য এই পাতায় যোগ করা।) 2060 = 080Ch আর 16385 = 4001h, তাই r0 = 0x4001080C, ঠিক GPIOA-র ODR. main 258 byte হওয়ার কারণও assembly-তে দেখা যায়: Clang ছয় পাকের লুপটিকে ছয়বার খুলে লিখেছে (loop unrolling).

Script দিয়ে বাইরের পৃথিবী

আসল যন্ত্রে button চাপে মানুষ, ওজন রাখে দোকানি। Virtual board-এ এগুলো আসে একটি JSON script থেকে, millisecond ধরে। বাজারঘরের smart scale-এর আসল firmware (scale.c) চালানো হলো নিজের লেখা ছোট script দিয়ে: শুরুতে 0 g, 150 ms-এ 500 g আলু।

$ cat my_scale.json
{"events": [{"t_ms": 0, "grams": 0}, {"t_ms": 150, "grams": 500}]}

$ python -B board.py run scale.elf --script my_scale.json --cycles 2400000
[     0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[     0.0000 ms] > load on the scale: 0 g
[     0.0729 ms] UART: scale ready: zero=400 counts, span=1400 counts per 2000 g, rate=65.50 Tk/kg
[   100.0889 ms] UART: raw=400 gross=0 g tare=0 g net=0 g price=0.00 Tk
[   150.0000 ms] > load on the scale: 500 g
[   200.0999 ms] UART: raw=750 gross=500 g tare=0 g net=500 g price=32.75 Tk
[   300.0000 ms] stopped: cycle limit (2400000) reached after 2400000 cycles

> দিয়ে শুরু লাইন script-এর input; UART: লাইন firmware-এর পাঠানো লেখা। 500 g-এ raw = 400 + 0.7 × 500 = 750 count, দাম (500 × 6550 + 500) ÷ 1000 = 3275 পয়সা = 32.75 টাকা, বাজারঘরের নির্ধারিত সংখ্যার সঙ্গে হুবহু। 300 ms-এ কোনো নতুন লাইন নেই, কারণ scale শুধু মান বদলালে লেখে। --cycles 2400000 মানে 2400000 ÷ 8000 = 300 ms পরে থামা। সময়ের হিসাব নিজে করে দেখুন:

F = 8_000_000                        # BG-M3 core clock (Hz)
MAX = (1 << 24) - 1                  # SysTick is a 24-bit down-counter

def load_for(period_s, f=F):
    """LOAD value for one SysTick interrupt every period_s seconds."""
    n = round(period_s * f)          # cycles per period = LOAD + 1
    return n - 1

for name, p in [("1 ms", 0.001), ("10 ms", 0.010), ("1 s", 1.0), ("3 s", 3.0)]:
    v = load_for(p)
    ok = "fits" if 0 < v <= MAX else "TOO BIG for 24 bits"
    print(f"{name:>5}: LOAD = {v:>9,}  {ok}")

print(f"longest tick at 8 MHz = {(MAX + 1) / F * 1000:.3f} ms")
print(f"CALIB 0x4001387F -> 10 ms LOAD = {0x4001387F & MAX:,}")

# blink.c: 6 toggles, each after 500 ticks of (7999 + 1) cycles
cycles = 6 * 500 * (load_for(0.001) + 1)
print(f"blink timer cycles = {cycles:,} = {cycles / 8000:.4f} ms")
real = 24_000_047                    # from 'exit(0) after 24000047 cycles'
print(f"extra cycles in the real run = {real - cycles} "
      f"(= {(real - cycles) / 8000:.4f} ms of startup and exit code)")

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

 1 ms: LOAD =     7,999  fits
10 ms: LOAD =    79,999  fits
  1 s: LOAD = 7,999,999  fits
  3 s: LOAD = 23,999,999  TOO BIG for 24 bits
longest tick at 8 MHz = 2097.152 ms
CALIB 0x4001387F -> 10 ms LOAD = 79,999
blink timer cycles = 24,000,000 = 3000.0000 ms
extra cycles in the real run = 47 (= 0.0059 ms of startup and exit code)

SysTick-এর counter ২৪ বিটের, তাই LOAD সর্বোচ্চ 16,777,215; 8 MHz-এ একটি tick সর্বোচ্চ প্রায় 2.097 s, আর 3 s-এর জন্য এক tick যথেষ্ট নয় (ছোট tick গুনে নিতে হয়)। Board-এর CALIB register-এর নিচের ২৪ বিট 79,999, যা 10 ms-এর LOAD; cold-storage monitor এটাই ব্যবহার করে। শেষ দুই লাইন board-এর log ব্যাখ্যা করে: timer-এর অংশ ঠিক 3000 ms, বাকি ৪৭টি cycle (0.0059 ms) শুরুর আর শেষের কোড। এই হিসাব virtual board-এর “১ নির্দেশ = ১ cycle” নিয়মে সঠিক; আসল chip-এ বাড়তি অংশটি আলাদা হবে।

Board কী নকল করে না

শেখার জন্য এই board সরল করা হয়েছে। প্রতিটি সরলীকরণ জানা থাকলে ভুল সিদ্ধান্ত এড়ানো যায়:

  • সময় (Spec decision 17, 20): ১টি নির্দেশ = ১টি cycle; exception-এ ঢোকা-বেরোনো ০ cycle. আসল Cortex-M3-এ নির্দেশভেদে ১ থেকে অনেক cycle, আর ARM-এর Cortex-M3 Technical Reference Manual অনুযায়ী wait-state ছাড়া মেমরিতে interrupt-এ ঢুকতে প্রায় ১২ cycle. Pending interrupt দেখা হয় নির্দিষ্ট “সীমায়”, তাই কোনো কোনো ক্ষেত্রে সর্বোচ্চ ২০,০০০ cycle দেরি হতে পারে।
  • Exception (Spec decision 19): HardFault, SysTick আর দুটি IRQ মডেল করা; NMI, SVC, PendSV, BASEPRI, আলাদা fault-এর ধরন, fault status register, MPU, FPU আর PSP নেই।
  • Peripheral (Spec decision 23–27): UART-এ পাঠানো তাৎক্ষণিক, baud rate-এর সময় নেই; ADC-র conversion তাৎক্ষণিক; I2C শুধু register-স্তরে, start-stop বা ACK-এর বিট-সময় নেই; button-এ কোনো bounce নেই, যদি না script নিজে bounce লেখে।
  • বিদ্যুৎ: voltage, current, noise, brown-out বা battery-র কোনো model নেই। Power-এর হিসাব আসবে datasheet থেকে (পর্ব ৬২)।
  • Toolchain (Spec decision 30): সাব-millisecond অঙ্কগুলো (যেমন .0054) compiler-এর version আর flag-এর ওপর নির্ভর করে; মান আর ক্রম নয়।

৬ · RTOS simulator আর local MQTT — সময়ের ভাগ আর network

মডিউল ৯-এ একসঙ্গে কয়েকটি কাজ (task) চালানোর প্রশ্ন আসবে: কে কখন CPU পাবে? rtos_sim.py একটি RTOS-এর scheduler-কে tick ধরে নকল করে। এটি আসল RTOS kernel নয়, কোনো firmware-ও চালায় না; প্রতিটি task একটি ছোট script (“৪ tick হিসাব”, “lock S”), আর simulator প্রতিটি tick-এ ঠিক করে কে চলবে। বড় priority সংখ্যা মানে বেশি জরুরি, FreeRTOS-এর রীতিতে (Spec decision 32).

সবচেয়ে বিখ্যাত উদাহরণ priority inversion: কম জরুরি L একটি mutex S ধরে আছে, বেশি জরুরি H সেটির জন্য অপেক্ষায়, আর মাঝারি M এসে L-কে সরিয়ে দেয়; ফলে H আটকে থাকে M-এর জন্য, যার সঙ্গে H-এর কোনো সম্পর্কই নেই। দুটি run পাশাপাশি (সত্যিকারের run; # চলছে, - তৈরি, B আটকে, . নেই):

$ python -B rtos_sim.py demo inversion          $ python -B rtos_sim.py demo inversion --inherit
  0123456789012345                                0123456789012345
H ..#BBBBBBBB##...                              H ..#BB##.........
M ....######......                              M ....---######...
L ##-#------#--#..                              L ##-##--------#..
H released 2 … finish 13 response 11            H released 2 … finish 7 response 5

এই Gantt chart বাঁ দিকে বলছে: tick 3-এ H আটকায় (B), tick 4–9 M চলে (######), আর H ছাড়া পায় শুধু tick 11-এ; H-এর response ১১ tick. ডান দিকে priority inheritance চালু: H আটকানোর সঙ্গে সঙ্গে L ধার করে H-এর priority 3, তাই tick 4-এ M এসে L-কে সরাতে পারে না; L tick 5-এ S ছাড়ে, H tick 7-এ শেষ, response ৫ tick. Simulator-এর event log-এ লেখা থাকে “L inherits priority 3”. সীমা: শুধু পূর্ণ tick, context switch-এর খরচ শূন্য, lock আর unlock-এর সময় শূন্য (Spec decision 32–33).

IoT-এর জন্য mqtt_demo.py lab-এর কম্পিউটারেই একটি MQTT broker (amqtt 0.12.2) চালায়, শুধু 127.0.0.1-এ, আর কয়েকটি paho-mqtt client দিয়ে বাজারঘরের device-এর ভূমিকা নেয়। MQTT-এর পুরো আলোচনা পর্ব ৭৩-এ; এখানে শুধু tool-এর ছবি। --quiet দিয়ে চালানোর অংশ (সত্যিকারের run, paho-mqtt 2.2.0, EPL-2.0 বা EDL-1.0):

$ python -B mqtt_demo.py --quiet
broker: amqtt 0.12.2 listening on 127.0.0.1 (port chosen at run time)

2. scale-1 publishes a weight reading: QoS 1, retained
    dashboard got bazarghar/scale/1/weight qos=1 retain=0 {"dev":"scale-1","seq":1,"gross_g":1400,"tare_g":150,"net_g":1250,"rate_paisa_per_kg":6550,"price_paisa":8188}
    -> net 1250 g x 65.50 Tk/kg = 8188 paisa = 81.88 Tk
…
4. phone-app connects later and subscribes to the weight topic: the retained message arrives at once
    phone-app got bazarghar/scale/1/weight qos=1 retain=1 {…}
…
6. coldroom-1 loses its connection without DISCONNECT: the broker publishes its Last Will
    dashboard got bazarghar/coldroom/1/status qos=1 retain=0 offline
…
broker stopped

ধাপ ৪-এ পরে আসা phone-app সঙ্গে সঙ্গে শেষ ওজন পায়: এটি retained message. ধাপ ৬-এ cold room-এর সংযোগ হঠাৎ কাটলে broker নিজেই “offline” ছড়ায়: এটি Last Will. সীমা (Spec decision 37): কোনো password নেই, TLS নেই, শুধু নিজের যন্ত্রে; আর amqtt 0.12.2-এর দুটি জায়গায় MQTT 3.1.1-এর নিয়ম থেকে বিচ্যুতি ছিল, যা run-এর সময় ছোট একটি patch দিয়ে ঠিক করা হয় (installed package বদলানো হয় না)। আসল device-এ এভাবে খোলা broker ব্যবহার করা নিরাপদ নয়; পর্ব ৭৬-এ (IoT security) এর কারণ।

৭ · পাতায়, নিজের কম্পিউটারে, আর আসল board-এ

এই কোর্সে কোড তিন জায়গায় চলতে পারে। পাতার ভেতরে কিছু বসাতে হয় না: Python চলে আপনার ব্রাউজারের Pyodide-এ, JavaScript ব্রাউজারের sandbox-এ, আর C যায় Wandbox-এর আসল compiler-এ, যেখান থেকে শুধু আউটপুট ফেরে। Wandbox-এর C চলে একটি সাধারণ x86 server-এ, Cortex-M-এ নয়; তাই সেখানে চলে firmware-এর যুক্তি, register নয়। এই অভ্যাসের নাম host testing: hardware-নির্ভর নয় এমন অংশ আগে সাধারণ কম্পিউটারে পরীক্ষা। নিচে smart scale-এর দামের নিয়ম, ঠিক firmware-এর সূত্রে:

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

/* same rule as the scale firmware: integer only, round half up */
static int32_t price_paisa(int32_t net_g)
{
    return (net_g * 6550 + 500) / 1000;
}

int main(void)
{
    const int32_t grams[]    = {150, 500, 1250, 0};
    const int32_t expected[] = {983, 3275, 8188, 0};
    for (int i = 0; i < 4; i++) {
        int32_t p = price_paisa(grams[i]);
        printf("%5d g -> %5d paisa = %d.%02d Tk\n",
               (int)grams[i], (int)p, (int)(p / 100), (int)(p % 100));
        assert(p == expected[i]);
    }
    printf("host test: 4 of 4 passed\n");
    return 0;
}

আসল আউটপুট (Wandbox, GCC):

  150 g ->   983 paisa = 9.83 Tk
  500 g ->  3275 paisa = 32.75 Tk
 1250 g ->  8188 paisa = 81.88 Tk
    0 g ->     0 paisa = 0.00 Tk
host test: 4 of 4 passed

চারটি মানই বাজারঘরের নির্ধারিত সংখ্যা, আর virtual board-এর scale.c একই সংখ্যা দেখায়। assert প্রতিটি ফল প্রত্যাশার সঙ্গে মেলায়; কেউ পরে সূত্রে ভুল ঢোকালে (যেমন +500 মুছে দিলে) 150 g-এ 982 আসবে আর program থেমে যাবে। Host-এ পরীক্ষা দ্রুত, কিন্তু একটি ফাঁদ মনে রাখুন: x86-এ int ৩২ বিট, কিছু ৮-বিট বা ১৬-বিট MCU-তে ১৬ বিট; তাই firmware-এ int32_t-এর মতো নির্দিষ্ট মাপের type দরকার (পর্ব ৩৪)।

নিজের কম্পিউটারে। এই পাতার sim8085.py, run8086.py, board.py, rtos_sim.py আর mqtt_demo.py কোর্সের নিজস্ব reference lab-এর tool: কোর্স তৈরির সময় এগুলো দিয়েই প্রতিটি পাতার “সত্যিকারের run” আউটপুট তৈরি হয়েছে, আর এগুলো সাইটে প্রকাশ করা হয় না। তাই আপনার কাজ দুই ভাগে: পাতার ভেতরের কোড-ব্লক (Pyodide-এ Python, Wandbox-এ C) নিজে চালানো, আর lab-এর ছাপা আসল আউটপুট পড়ে হাতে মেলানো। Lab-এর open-source অংশগুলো (NASM, Unicorn, Zig-এর সঙ্গে আসা Clang, amqtt, paho-mqtt) নির্দিষ্ট version-এ বাঁধা, কারণ অন্য version-এ cycle সংখ্যা সামান্য বদলাতে পারে (Spec decision 30); reference lab-এর README অনুযায়ী এদের কোনোটিতে usage-তথ্য পাঠানোর (telemetry) কোড পাওয়া যায়নি।

নিজের যন্ত্রে হাতে-কলমে অনুশীলন করতে চাইলে বহুল প্রচলিত free tool-ই যথেষ্ট, যেমন:

  • 8085: আপনার পছন্দের যেকোনো 8085 simulator, যেখানে program লিখে register আর flag দেখা যায়।
  • 8086: assemble করতে NASM, আর org 100h-এর .COM program চালাতে একটি DOS emulator.
  • Cortex-M: Arm GNU Toolchain বা Clang-এর মতো cross-compiler; -S দিয়ে C থেকে তৈরি Thumb assembly নিজে দেখা যায়।
  • RTOS: FreeRTOS বা Zephyr, দুটিরই সাধারণ কম্পিউটারে চালানোর মতো port আছে।
  • MQTT: Mosquitto-র মতো একটি broker আর যেকোনো MQTT client, শুধু নিজের যন্ত্রে (127.0.0.1) চালিয়ে।

এই tool-গুলো lab-এর Spec decision মানে না, তাই এই পাতার সংখ্যা হুবহু মিলবে এমন নিশ্চয়তা নেই; মান, ক্রম আর যুক্তি মেলানোই সেখানে লক্ষ্য।

আসল board-এ। এই কোর্সের কোনো কাজে আসল hardware লাগে না, আর এই পাতার কোনো আউটপুট আসল board থেকে নয়। তবু যিনি হাতে-কলমে যেতে চান, তাঁর জন্য প্রতিটি lab tool-এর বাস্তব রূপ:

Lab-এআসল যন্ত্রে একই কাজতখন নতুন যা আসে
sim80858085 trainer kit (hex keypad, 7-segment display), হাতে assemble করা byte কি-প্যাডে ঢোকানোcrystal-ভেদে আলাদা clock, ধীর মেমরিতে wait state, কোনো trace নেই
NASM + Unicorn8086 trainer kit, বা org 100h-এর program .COM ফাইল হিসেবে DOS emulator-এআসল 8086-এর চারটি আচরণ (PUSH SP ইত্যাদি), আসল DOS-এর পূর্ণ সেবা
বাজারঘর boardCortex-M3 board (যেমন STM32F103-ভিত্তিক), বা Cortex-M0+ (RP2040), AVR (ATmega328P, Arduino Uno), ESP32আসল register map (reference manual), clock সেটআপ, flash লেখা, debug probe
rtos_simসেই board-এ FreeRTOS বা Zephyr-এর মতো আসল RTOScontext switch-এর সময়, stack overflow, আসল interrupt
mqtt_demoRaspberry Pi বা PC-তে Mosquitto-র মতো broker, ESP32-এর Wi-Fi deviceWi-Fi হারানো, reconnect, TLS আর certificate, battery

আসল Cortex-M board-এ program বসাতে আর ধাপে ধাপে চালাতে লাগে একটি debug probe, যা সাধারণত SWD (দুটি সংকেত-তার: SWDIO আর SWCLK) দিয়ে chip-এর সঙ্গে কথা বলে; অনেক development board-এ probe board-এর ওপরেই থাকে। Firmware-এর UART লেখা দেখতে লাগে USB-serial adapter আর একটি terminal program, আর তারের সংকেত চোখে দেখতে একটি logic analyzer. Debugging-এর পুরো কৌশল পর্ব ৩৮-এ। Board-এর পুরো ব্যবস্থাকে কম্পিউটার-চালিত নকল sensor দিয়ে পরীক্ষা করার নাম hardware-in-the-loop, যা পর্ব ৬৪-এ।

নিরাপত্তা: আসল board-এ গেলে শুধু USB-র 5 V বা ছোট ব্যাটারির নিচু voltage নিয়ে কাজ করুন। Mains (২২০ V) তারে কখনো নিজে হাত দেবেন না। Li-ion ব্যাটারি ছোট-সার্কিট হলে আগুন ধরতে পারে; সুরক্ষা-সার্কিটসহ ব্যাটারি আর চার্জার ব্যবহার করুন।

আরও গভীরে: Simulator-এর বিশ্বস্ততার কয়েকটি স্তর আছে। এই কোর্সের tool-গুলো “functional” স্তরের: প্রতিটি নির্দেশের ফল ঠিক, সময় নিয়মে বাঁধা। এর ওপরে cycle-accurate simulator, যা pipeline, bus আর মেমরির wait state ধরে প্রতিটি clock গোনে; আরও ওপরে chip-নকশাকারীদের RTL simulation, যেখানে chip-এর হার্ডওয়্যার-বর্ণনা নিজেই চলে, কিন্তু গতি অনেক ধীর। Unicorn এসেছে QEMU-র CPU অংশ থেকে, আর QEMU দ্রুত চলার জন্য অতিথি-কোডকে টুকরো টুকরো অনুবাদ করে (dynamic binary translation); তাই সে cycle গোনে না, আর virtual board-এর সময় Python-এ আলাদা নিয়মে রাখা (Spec decision 17).

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

  • Simulator আর emulator-এর পার্থক্য? Simulator একটি model দিয়ে আচরণ নকল করে; emulator অন্য CPU-র আসল machine code চালায়। সীমারেখা ঝাপসা, তাই tool কী নকল করে তা বলাই আসল উত্তর।
  • Cross-compiler কী? যে compiler এক যন্ত্রে চলে কিন্তু অন্য CPU-র জন্য কোড বানায়, যেমন PC-তে চলে ARM Cortex-M-এর কোড বানানো Clang বা GCC.
  • 8085-এ MVI C,N / L: DCR C / JNZ L-এর মোট T-state? 7 + 4N + 10(N − 1) + 7 = 14N + 4.
  • Cortex-M reset-এর পরে প্রথম কী পড়ে? Vector table-এর প্রথম word থেকে MSP, দ্বিতীয় word থেকে reset handler-এর ঠিকানা।
  • Map file-এ কী থাকে? প্রতিটি section আর symbol কোন ঠিকানায়, কত বড়; flash আর RAM-এর ব্যবহার বোঝার প্রধান উপায়।

৮ · AI-এর যুগে lab — AI-এর উত্তর tool দিয়ে যাচাই

AI assistant-কে বলা যায় “একটি 8085 program লিখে দিন” বা “STM32-এর জন্য blink লিখে দিন”। কিন্তু lab-এর আসল শক্তি AI-এর উত্তর যাচাই করা। এই বিষয়ে AI-এর পরিচিত ভুল: 8085, 8086 আর Z80-এর নির্দেশ ও flag মিশিয়ে ফেলা; T-state বা cycle ভুল গোনা; কোনো নির্দিষ্ট microcontroller-এর register-এর নাম আর ঠিকানা বানিয়ে লেখা; ISR-এ ভাগ করা variable-এ volatile ভুলে যাওয়া বা interrupt-এর সময় ভেঙে যেতে পারে এমন read-modify-write; ISR-এর ভেতরে delay বা printf; RTOS-এর API ভুলভাবে ব্যবহার; baud rate আর I2C/SPI mode-এর ভুল হিসাব; আর অনিরাপদ IoT ডিফল্ট (কোডে লেখা password, TLS ছাড়া MQTT, signature ছাড়া update).

আরেকটি নতুন ভুল এই পর্বের বিষয়েই: AI প্রায়ই emulator-এর আউটপুটকে আসল chip-এর আচরণ বলে চালায়, যেমন “Unicorn-এ PUSH SP FFFEh দিয়েছে, তাই 8086-এও তাই”। Tool-এর সীমা জানা থাকলে এই ভুল ধরা সহজ।

AI-কে এমনভাবে প্রশ্ন করুন যাতে উত্তর সরাসরি lab-এ যাচাই করা যায়:

আমি Intel 8085 শিখছি (8080 বা Z80 নয়), clock 3 MHz. আমার simulator Intel-এর syntax নেয়: label শেষে কোলন, hex শেষে H (যেমন 0FFH), ORG আর END আছে। কাজ: 2050H থেকে N টি byte যোগ করে 2060H-এ রাখো; N থাকবে 204FH-এ। ১. শুধু documented 8085 নির্দেশ ব্যবহার করো। ২. প্রতিটি নির্দেশের T-state Intel 8085 user's manual-এর টেবিল থেকে লেখো, আর N-এর সাপেক্ষে মোট T-state-এর সূত্র দাও। ৩. N = 4 আর data 05H, 0AH, 14H, 1EH হলে শেষে A, 2060H আর flag কী হবে, তা আগে থেকে বলো। ৪. N = 0 হলে program কী করবে, আর সেটি ঠিক করার উপায় বলো। ৫. কোনো সংখ্যায় নিশ্চিত না হলে স্পষ্ট বলো; অনুমানকে তথ্য হিসেবে লিখো না।

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

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

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

প্র ০১“আমার program simulator-এ ঠিক চলেছে” — এই কথার মানে কতটুকু, আর কতটুকু নয়?

কথাটির মানে নির্ভর করে simulator কোন স্তরের তার ওপর। সবচেয়ে নিচে functional স্তর: প্রতিটি নির্দেশের ফল (register, flag, মেমরি) ঠিক, কিন্তু সময় হয় গোনাই হয় না, নয়তো সরল নিয়মে গোনা হয়। এই কোর্সের sim8085 এই স্তরের, তবে Intel-এর টেবিল থেকে T-state যোগ করে (Spec decision 2). তার ওপরে cycle-accurate স্তর, যেখানে pipeline, bus-এর লড়াই আর মেমরির wait state ধরে প্রতিটি clock-টিক নকল হয়। সবচেয়ে ওপরে chip-নকশাকারীদের RTL বা gate-স্তরের simulation, যা নিখুঁত কিন্তু এত ধীর যে পুরো firmware চালানো কঠিন।

তাই “simulator-এ ঠিক চলেছে” মানে: যুক্তি ঠিক, নির্দেশ ঠিক, ক্রম ঠিক। এর মানে নয়: সময় আসল chip-এ হুবহু এক, বৈদ্যুতিক সংকেত ঠিক, বা বাইরের যন্ত্র ঠিক সাড়া দেবে। যেমন sim8085-এ ১১৭টি T-state হলে 3 MHz-এ 39 µs, কিন্তু যে kit-এর মেমরি ধীর আর wait state যোগ করে, সেখানে সময় বেশি হবে; simulator তা জানে না।

ইতিহাসেও এই পার্থক্য পরিচিত। ১৯৭০ আর ৮০-এর দশকে microprocessor নির্মাতা আর tool-নির্মাতারা “in-circuit emulator” নামে যন্ত্র বানাতেন, যা আসল chip-এর socket-এ বসে chip-এর জায়গা নিত আর ভেতরের অবস্থা দেখাত; উদ্দেশ্য ছিল ঠিক এই ফাঁক বন্ধ করা: সফটওয়্যারে যা দেখা যায় না, তা আসল সার্কিটে দেখা। আজ Cortex-M chip-এর ভেতরেই debug hardware থাকে, যা SWD দিয়ে একই কাজ অনেক সস্তায় করে।

ভালো অভ্যাস হলো tool-এর দাবি তিন স্তরে যাচাই: simulator-এ যুক্তি, হাতে হিসাবে সময়, আর আসল hardware বা datasheet-এ বাস্তবতা। এই কোর্স প্রথম দুটি করে, তৃতীয়টির জন্য datasheet-এর উদ্ধৃতি দেয়।

মূল উপলব্ধি: Simulator একটি প্রশ্নের উত্তর দেয়, সব প্রশ্নের নয়। কোন প্রশ্ন, তা জানাই ব্যবহারকারীর দক্ষতা।

প্র ০২8086 চালাতে 386-শ্রেণির emulator কেন, আর তার চারটি পার্থক্য পরীক্ষার্থীর জন্য কেন গুরুত্বপূর্ণ?

x86 পরিবারের একটি বড় গুণ backward compatibility: ১৯৭৮ সালের 8086-এর জন্য লেখা বেশিরভাগ কোড পরের প্রজন্মের CPU-র real mode-এ চলে। তাই আধুনিক emulator (QEMU, তার থেকে আসা Unicorn) আলাদা করে “৮০৮৬ mode” রাখে না; তারা পরের প্রজন্মের CPU নকল করে, আর 8086-এর কোড সেখানে প্রায় সবসময় একই ফল দেয়। একটি পুরোপুরি নির্ভুল 8086 emulator নতুন করে লেখার চেয়ে একটি পরীক্ষিত, বহু-ব্যবহৃত engine নিয়ে তার পার্থক্যগুলো লিখে রাখা বেশি নির্ভরযোগ্য পথ।

কিন্তু “প্রায়” শব্দটিই গুরুত্বপূর্ণ। Intel নিজেই তার Software Developer's Manual-এ কিছু পার্থক্য লিখে রেখেছে। PUSH SP: 8086 নতুন SP (দুই কমানোর পরের মান) লেখে, 286 থেকে পরের CPU পুরোনো মান। Shift আর rotate: manual অনুযায়ী 8086 count-কে ছোট করে না, কিন্তু পরের CPU নিচের ৫ বিট নেয়, তাই CL = 33 দিলে দুই জায়গায় ফল আলাদা। Divide error-এ 8086 stack-এ রাখে পরের নির্দেশের ঠিকানা, পরের CPU রাখে DIV নিজের ঠিকানা, যাতে handler চাইলে নির্দেশটি আবার চালাতে পারে। আর PUSHF-এ ওপরের চার বিটের মান আলাদা।

পরীক্ষার্থীর জন্য এটি দুইভাবে জরুরি। প্রথমত, লিখিত পরীক্ষায় প্রশ্ন 8086-এর; emulator-এ দেখা ফল কোনো একটি পার্থক্যের জায়গায় পড়লে খাতায় ভুল উত্তর যাবে। দ্বিতীয়ত, এটি সাধারণ শিক্ষা: যেকোনো tool-এর ফলকে “সত্য” ধরার আগে জানতে হয় tool কোন যন্ত্রের নকল। এই lab সেই কারণেই চারটি পার্থক্যকে test দিয়ে আটকে রেখেছে, আর উদাহরণগুলো সেগুলো এড়িয়ে লেখা (Spec decision 15).

একই প্রশ্ন ARM-এও আসে: Unicorn-এর Cortex-M3 model নির্দেশের ফল দেয়, কিন্তু exception-এর পুরো নিয়ম Unicorn করে না, তাই board.py সেটি Python-এ লেখে (Spec decision 19).

মূল উপলব্ধি: Backward compatibility “প্রায় সব” রক্ষা করে, “সব” নয়। পার্থক্যগুলো লিখে রাখা আর test-এ বেঁধে রাখাই একটি tool-কে বিশ্বাসযোগ্য করে।

প্র ০৩একটি নির্দিষ্ট compiler version বেঁধে রাখা আর প্রতিবার একই আউটপুট পাওয়া embedded কাজে এত জরুরি কেন?

এই পাতার blink-এর log-এ প্রথম LED জ্বলে 500.0054 ms-এ। শেষের .0054 এসেছে reset থেকে SysTick চালু হওয়া পর্যন্ত প্রায় ৪৩টি নির্দেশ থেকে। Clang-এর অন্য version ভিন্নভাবে optimize করলে নির্দেশ-সংখ্যা বদলাবে, আর সেই অঙ্কও বদলাবে। তাই lab নির্দিষ্ট version বাঁধে (ziglang 0.17.1, অর্থাৎ Clang 22.1.8) আর Spec decision 30-এ লিখে রাখে: মান আর ক্রম compiler-নির্ভর নয়, সাব-millisecond অঙ্ক compiler-নির্ভর।

বাস্তব firmware-এ এই প্রশ্ন আরও গুরুতর। একই উৎস থেকে দুই মাস পরে build করা firmware যদি আলাদা binary দেয়, তাহলে মাঠে চলা যন্ত্রের সমস্যা নিজের টেবিলে আবার তৈরি করা কঠিন হয়। একটি compiler upgrade একটি সময়-সংবেদনশীল লুপকে দ্রুত করে দিতে পারে, বা undefined behavior-এর ওপর দাঁড়ানো কোডকে হঠাৎ ভেঙে দিতে পারে। তাই অনেক embedded দল toolchain-এর version প্রকল্পের অংশ হিসেবে লিখে রাখে, আর একই উৎস থেকে বাইট-বাই-বাইট একই binary পাওয়ার চেষ্টা করে, যাকে বলে reproducible build.

নিরাপত্তা-সংবেদনশীল ক্ষেত্রে (গাড়ি, চিকিৎসা-যন্ত্র, শিল্প) এর চেয়েও বেশি দরকার হয়: functional safety মানদণ্ডগুলো tool-এর ওপর আস্থার যুক্তি চায়, কারণ compiler-এর একটি bug সরাসরি যন্ত্রের আচরণ বদলাতে পারে। এর বিস্তারিত পর্ব ৬৩-এ।

Lab-এর সব tool deterministic রাখার আরেকটি লাভ শিক্ষায়: এই পাতার প্রতিটি সংখ্যা যতবার চালানো হোক হুবহু একই আসে, তাই সেগুলো স্থির রেফারেন্স। অন্য কোনো tool-এ নিজে চালিয়ে কোনো সংখ্যা না মিললে প্রথম প্রশ্ন হবে “আমার tool আর version কোনটি?” এই প্রশ্ন করার অভ্যাস বাস্তব কাজে অনেক সময় বাঁচায়।

মূল উপলব্ধি: Toolchain-ও firmware-এর অংশ। Version লিখে না রাখলে “গতকাল চলছিল” আর “আজ চলছে না”-র মাঝের পার্থক্য খোঁজা প্রায় অসম্ভব হয়ে যায়।

প্র ০৪Virtual board-এ “১টি নির্দেশ = ১টি cycle” — এতে কী শেখা যায়, আর কোন ভুল ধারণা জন্মাতে পারে?

সরল নিয়মের বড় সুবিধা হিসাব সহজ হওয়া। SysTick-এর LOAD = 7999 মানে 8000 cycle = 1 ms, ৫০০টি tick = 500 ms; log-এর প্রতিটি সংখ্যা হাতে মেলানো যায়। Timer, interrupt আর WFI-এর ধারণা শিখতে এই স্পষ্টতা খুব কাজের। আর timer-নির্ভর সময়, যেমন LED-এর 500 ms পরপর জ্বলা, আসল chip-এও একই, কারণ SysTick গোনে clock, নির্দেশ নয়।

কিন্তু সফটওয়্যারের গতি নিয়ে ভুল ধারণা জন্মাতে পারে। আসল Cortex-M3-এ বেশিরভাগ সাধারণ নির্দেশ এক cycle-এ শেষ হয়, কিন্তু load-store, ভাগ, লাফ বা একাধিক register-এর load বেশি cycle নেয়। ARM-এর Cortex-M3 Technical Reference Manual অনুযায়ী wait-state ছাড়া মেমরিতে interrupt-এ ঢুকতে প্রায় ১২ cycle লাগে, আর একটির পর আরেকটি interrupt-এ (tail-chaining) কম। আবার বেশি clock-এ flash মেমরি CPU-র সঙ্গে তাল রাখতে পারে না, তাই flash-এ wait state যোগ করতে হয়; যেমন STM32F1 পরিবারের reference manual বেশি clock-এ flash-এর জন্য এক বা দুই wait state-এর কথা বলে। Virtual board এর কিছুই গোনে না (Spec decision 17).

আরেকটি সূক্ষ্ম পার্থক্য interrupt-এর latency. Board pending interrupt দেখে নির্দিষ্ট “সীমায়”, যেমন peripheral register-এ লেখার পরে বা প্রতি ২০,০০০ cycle-এ (Spec decision 20). ফলে কোনো ক্ষেত্রে interrupt দেরিতে নেওয়া হতে পারে, যা আসল chip-এ হতো না। তাই এই board-এ মাপা interrupt latency কখনো আসল chip-এর latency হিসেবে লিখবেন না।

সঠিক ব্যবহার তাই: ক্রম, মান, যুক্তি আর timer-ভিত্তিক সময় board থেকে; নির্দেশ-গোনা সময়, latency আর power datasheet ও reference manual থেকে। পর্ব ৫৪-এ (Real-time system) WCET-এর আলোচনায় এই পার্থক্য কেন্দ্রীয় হবে।

মূল উপলব্ধি: সরল model শেখায় “কী ঘটে”; “কত দ্রুত ঘটে” জানতে আসল chip-এর দলিল লাগে।

প্র ০৫Simulator থেকে আসল board-এ গেলে কোন নতুন সমস্যা আসে, আর host testing ও HIL কীভাবে সেই সেতু বাঁধে?

Virtual board-এ button একবার চাপলে একটি পরিষ্কার edge আসে। আসল button-এর ধাতব পাত কয়েক millisecond ধরে লাফায় (bounce), ফলে একটি চাপ কয়েকটি edge হয়ে যায়; পর্ব ৪২ এর সমাধান শেখাবে। ADC-র মান আসল load cell-এ স্থির থাকে না, noise থাকে; তাপমাত্রার সঙ্গে zero সরে যায়। UART-এর দুই প্রান্তের clock-এ সামান্য পার্থক্য থাকলে byte ভুল আসে। বিদ্যুৎ কমে গেলে (brown-out) chip অদ্ভুত আচরণ করতে পারে। আর এসবের সঙ্গে আসে flash-এ program লেখা, debug probe-এর সংযোগ, ভুল তার।

এর মানে simulator অকেজো নয়; বরং কাজ ভাগ করা দরকার। প্রথম স্তর host testing: যে যুক্তি hardware-নির্ভর নয় (দাম, calibration, alarm-এর hysteresis), তা সাধারণ কম্পিউটারে দ্রুত, হাজারবার পরীক্ষা করা। দ্বিতীয় স্তর simulator বা virtual board: register আর interrupt-এর ক্রম। তৃতীয় স্তর HIL: আসল board, কিন্তু sensor-এর জায়গায় একটি কম্পিউটার নিয়ন্ত্রিত সংকেত দেয়, যাতে অসম্ভব বা বিপজ্জনক অবস্থাও (যেমন cold room-এ −25 °C) নিরাপদে পরীক্ষা করা যায়। শেষে মাঠে পরীক্ষা।

আসল hardware-এর একটি বিখ্যাত শিক্ষা ১৯৯৭ সালের Mars Pathfinder: মঙ্গলে নামার পরে যানটি বারবার নিজে reset হচ্ছিল। প্রকাশিত বিবরণ অনুযায়ী কারণ ছিল priority inversion, আর সমাধান ছিল পৃথিবী থেকে পাঠানো একটি সেটিং বদলে mutex-এ priority inheritance চালু করা। এই পাতার RTOS simulator ঠিক এই ঘটনার একটি ছোট রূপ দেখায়। মাটিতে পরীক্ষায় সমস্যাটি সহজে ধরা পড়েনি, কারণ ঘটনাগুলোর বিশেষ সময়-মিল দরকার ছিল।

আসল board-এ debug করার মূল হাতিয়ার SWD বা JTAG দিয়ে যুক্ত debug probe. JTAG-এর মানদণ্ড IEEE 1149.1, যা ১৯৯০ সালে গৃহীত হয়েছিল মূলত board-এর সংযোগ পরীক্ষার জন্য; পরে এটি chip debugging-এরও পথ হয়ে যায়।

মূল উপলব্ধি: প্রতিটি স্তর আলাদা ধরনের bug ধরে। Simulator-এ যা ধরা যায় তা সেখানেই ধরুন, যাতে আসল board-এর সময় শুধু আসল board-এর সমস্যায় যায়।

অনুশীলন

প্রথমটিতে একটি program লিখবেন; বাকিগুলোতে ভুল খোঁজা, আউটপুট অনুমান আর হাতে হিসাব।

  1. Program লিখুন (বাস্তবায়ন): sum3.asm-কে সাধারণ করুন: ব্যাগের সংখ্যা N থাকবে 204FH-এ, ওজন 2050H থেকে, মোট রাখবেন 2060H-এ। Simulator-এর জন্য pragma লিখুন যাতে N = 4 আর ওজন 05H, 0AH, 14H, 1EH হয়। মোট T-state-এর সূত্র N-এর সাপেক্ষে বের করুন, আর N = 0 দিলে কী হবে বলুন।
    ;@set 204FH 04H,05H,0AH,14H,1EH
    ;@show 2060H 1
            ORG 2000H
    START:  LDA 204FH       ; A = N            (13 T)
            MOV C,A         ; C = counter      (4 T)
            LXI H,2050H     ; HL -> first bag  (10 T)
            XRA A           ; total = 0        (4 T)
    LOOP:   ADD M           ;                  (7 T)
            INX H           ;                  (6 T)
            DCR C           ;                  (4 T)
            JNZ LOOP        ; 10 taken, 7 not
            STA 2060H       ;                  (13 T)
            HLT             ;                  (5 T)
            END START

    একটি ;@set-এ পাঁচটি byte দিলে 204FH থেকে পরপর বসে: N আর চারটি ওজন। সত্যিকারের run:

    A=41 B=00 C=00 D=00 E=00 H=20 L=54 SP=0000 PC=2012
    Flags: S=0 Z=1 AC=1 P=1 CY=0   (F=54H)
    Memory 2060H..2060H:
      2060H: 41
    Instructions: 22   T-states: 154

    5 + 10 + 20 + 30 = 65 = 41H, অর্থাৎ 6500 g. সূত্র: শুরু 13 + 4 + 10 + 4 = 31; প্রতি পাক 7 + 6 + 4 = 17, আর N − 1 বার লাফ (10) ও একবার না-লাফ (7); শেষ 13 + 5 = 18. মোট T = 31 + 17N + 10(N − 1) + 7 + 18 = 27N + 46. N = 4-এ 108 + 46 = 154, simulator-এর সঙ্গে মেলে। N = 0 হলে বিপদ: প্রথম DCR C 00H থেকে FFH করে, Z = 0, তাই লুপ ২৫৬ বার ঘোরে আর 2050H থেকে ২৫৬টি ঘর যোগ করে। সমাধান: LDA-র পরে A = N, তাই সেখানেই ORA A আর JZ দিয়ে সরাসরি STA 2060H-এ লাফ দিন; তখন A = 0, তাই 2060H-এ 00H লেখা হবে। আর মোট 255 পেরোলে (25.5 kg-এর বেশি) CY হারিয়ে যায়; ১৬-বিট যোগফলের জন্য পর্ব ১১ দেখুন।

  2. ভুলটি খুঁজুন (timing): একজন শিক্ষার্থী লিখেছেন: “sim8085-এর trace-এ sum3.asm ১১৭টি T-state নিল। আমার 8085 kit-এর crystal 6.144 MHz, তাই kit-এ সময় = 117 × 0.333 µs = 39 µs, আর kit-এও ঠিক এতটাই হবে।” দুটি ভুল খুঁজে বের করুন আর সঠিক সময় হিসাব করুন।

    ভুল ১ (clock): 0.333 µs হলো 3 MHz clock-এর T-state, যা 6 MHz crystal থেকে আসে। 8085 crystal-এর frequency ২ দিয়ে ভাগ করে, তাই এখানে CPU clock = 6.144 ÷ 2 = 3.072 MHz. ধাপে:

    1. f = 6.144 MHz ÷ 2 = 3.072 MHz.
    2. এক T-state = 1 ÷ 3.072 MHz ≈ 0.3255 µs.
    3. সময় = 117 × 0.3255 µs ≈ 38.09 µs (ঠিক মান 117 ÷ 3.072 = 38.0859… µs).

    ভুল ২ (“kit-এও ঠিক এতটাই”): simulator-এ কোনো wait state নেই (Spec decision 2). kit-এর মেমরি ধীর হলে READY সংকেত দিয়ে wait state যোগ হয়, আর প্রতিটি মেমরি-চক্রে বাড়তি T-state লাগে; তখন সময় বেশি। তাই সঠিক কথা হবে: “wait state না থাকলে প্রায় 38.09 µs.” Simulator সময়ের ন্যূনতম ছবি দেয়, kit-এর বাস্তব সময় নয়।

  3. আউটপুট অনুমান করুন: sum3.asm চালানো হলো --set 2050H=80H,90H,0F0H দিয়ে (তিনটি ভারী ব্যাগ)। শেষে A, [2053H], Z, CY আর পুরো flag byte (F) কী হবে? মোট T-state কি বদলাবে?

    প্রথম যোগ: 00 + 80 = 80H. দ্বিতীয়: 80 + 90 = 110H, ৮ বিটে A = 10H, CY = 1. তৃতীয়: 10 + F0 = 100H, A = 00H, CY = 1. তাই A = 00H, [2053H] = 00H. কিন্তু শেষ flag আসে DCR C থেকে, যা CY ছোঁয় না (Spec decision 4): Z = 1 (C = 0), CY = 1 থেকে যায়। S = 0, AC = 1 (DCR-এ পুরোনো নিচের nibble 1, শূন্য নয়), P = 1 (00H-এ শূন্যটি 1, জোড়)। F = 40 + 10 + 04 + 01 = 55H. Simulator-এর আসল run:

    A=00 B=00 C=00 D=00 E=00 H=20 L=53 SP=0000 PC=2010
    Flags: S=0 Z=1 AC=1 P=1 CY=1   (F=55H)
    Memory 2050H..2053H:
      2050H: 80 90 F0 00
    Instructions: 17   T-states: 117

    T-state বদলায়নি (১১৭), কারণ লাফের সংখ্যা data-র ওপর নয়, C-র ওপর নির্ভর করে। শিক্ষা: মোট 512 (200H) ৮ বিটে শূন্য দেখায়; CY = 1 না দেখলে ফলকে ভুলভাবে “শূন্য ওজন” পড়া হতো। আর এই উদাহরণে CY = 1 এসেছে শেষ যোগ থেকে, DCR থেকে নয়; trace না পড়লে এটি বোঝা কঠিন।

  4. হাতে হিসাব (SysTick আর log): virtual board-এ (8 MHz, period = LOAD + 1 cycle) cold-storage monitor প্রতি 10 ms-এ SysTick নেয় আর ১০০টি tick পরপর তাপমাত্রা পড়ে। (ক) LOAD কত? (খ) 20 s-এর run-এ মোট কত cycle? (গ) একই firmware 72 MHz-এর একটি আসল Cortex-M3-এ 10 ms tick-এর জন্য LOAD কত হবে, আর সেটি ২৪ বিটে আঁটবে কি? (ঘ) board-এর log-এ শেষ লাইন “exit(0) after 160000892 cycles”: ঠিক 20 s-এর চেয়ে কত বেশি, আর তা ms-এ কত?
    1. (ক) 10 ms-এ cycle = 0.010 s × 8 000 000 Hz = 80 000; LOAD = 80 000 − 1 = 79 999. এটি board-এর CALIB register-এর নিচের ২৪ বিটের মানের সঙ্গে মেলে (0x4001387F-এর 0x01387F = 79 999).
    2. (খ) 20 s × 8 000 000 = 160 000 000 cycle (২০০০টি tick × 80 000).
    3. (গ) 0.010 × 72 000 000 = 720 000; LOAD = 719 999. ২৪ বিটের সর্বোচ্চ 16 777 215, তাই আঁটে। (72 MHz-এ সবচেয়ে লম্বা tick 16 777 216 ÷ 72 MHz ≈ 233 ms.)
    4. (ঘ) 160 000 892 − 160 000 000 = 892 cycle বেশি; 892 ÷ 8000 = 0.1115 ms. তাই শেষ লাইনের সময় 20000.1115 ms, যা reference lab-এর cold-room run-এর আসল শেষ লাইনের সঙ্গে মেলে। এই বাড়তি cycle হলো শুরুর কোড আর শেষ TELEMETRY লাইন ছাপার কাজ; virtual board-এ ১ নির্দেশ = ১ cycle, তাই আসল chip-এ এই অংশ আলাদা হবে, কিন্তু 10 ms-এর tick timer-এর কারণে একই থাকবে।

    (ক), (গ) আর ২৪-বিটের সীমা এই পাতার ব্রাউজার-Python ব্লকের load_for() দিয়ে যাচাই করা যায়; (ঘ)-এর শেষ লাইন lab-এর প্রত্যাশিত আউটপুট ফাইলে আছে।

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

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

ক্রমএকটি Cortex-M firmware লেখা থেকে LED জ্বলা পর্যন্ত ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. 📄 C-তে firmware লেখা (ISR, main, register-এর ঠিকানা header থেকে)
  2. ⚙️ Cross-compiler প্রতিটি C ফাইলকে Thumb object file-এ বদলায়
  3. 🔗 Linker, linker script মেনে, ELF ফাইল আর map file বানায়
  4. 🔌 Reset-এ CPU vector table থেকে MSP আর reset handler-এর ঠিকানা পড়ে
  5. 🧹 Reset handler .data কপি করে, .bss শূন্য করে, main ডাকে
  6. 💡 main timer চালু করে; interrupt আসে, LED জ্বলে-নেভে

একটি x86 ল্যাপটপে চলা Clang --target=thumbv7m-none-eabi দিয়ে ARM Cortex-M3-এর machine code বানাল। এই কাজে Clang-কে কী বলা হয়?

  • Emulator
  • Cross-compiler
  • Simulator
  • Disassembler

আসল Intel 8086-এ SP = FFFEH অবস্থায় PUSH SP চলল। Intel-এর documented আচরণ অনুযায়ী stack-এ কোন মান লেখা হয়?

  • FFFCH
  • FFFEH
  • 0000H
  • FFFFH

8085-এ এই অংশটি চলল: MVI C,03H (7 T), তারপর L: DCR C (4 T), JNZ L (লাফ দিলে 10 T, না দিলে 7 T). মোট কতটি T-state?

  • 42
  • 49
  • 46
  • 53

8 MHz clock-এ SysTick দিয়ে প্রতি 1 ms-এ একটি interrupt চাই। SysTick-এর period = LOAD + 1 cycle হলে LOAD কত হবে?

  • 8000
  • 800
  • 79 999
  • 7999

একটি virtual Cortex-M3 board ধরে নেয় “১টি নির্দেশ = ১টি cycle”, আর exception-এ ঢোকা-বেরোনো ০ cycle. এর log থেকে কোন সিদ্ধান্তটি সবচেয়ে নিরাপদ?

  • একটি ISR-এর latency আসল chip-এও ঠিক এতটাই হবে
  • Timer-ভিত্তিক সময় আর ঘটনার ক্রম ভরসা করা যায়; নির্দেশ-গোনা সময় datasheet থেকে নিতে হবে
  • Firmware-এর বিদ্যুৎ খরচ log থেকে হিসাব করা যায়
  • যেকোনো দুটি log লাইনের ব্যবধান আসল chip-এর ব্যবধান

একটি preemptive RTOS-এ L (priority 1) একটি mutex ধরে আছে, H (priority 3) সেটির জন্য আটকে, আর M (priority 2) তৈরি হলো। Mutex-এ priority inheritance চালু থাকলে কী হয়?

  • L সাময়িকভাবে priority 3 পায়, M তাকে সরাতে পারে না, L mutex ছাড়লেই H চলে
  • M আগে পুরো চলে, তারপর L, তারপর H
  • RTOS mutex-টি L-এর কাছ থেকে কেড়ে H-কে দেয়
  • H-এর priority কমে 1 হয়ে যায়

শব্দকোষ

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

মনে রাখুন

  1. Simulator model দিয়ে আচরণ নকল করে, emulator অন্য CPU-র আসল কোড চালায়, cross-compiler নিজের যন্ত্রে বসে অন্য CPU-র কোড বানায়।
  2. sim8085: asm, run, trace, dis; trace-এর প্রতিটি লাইন নির্দেশের পরের অবস্থা। sum3.asm: ১৭টি নির্দেশ, ১১৭টি T-state, T = 27N + 36.
  3. run8086: NASM + Unicorn, 1000:0100h-এ program; Unicorn 386-শ্রেণির, চারটি পার্থক্য (PUSH SP, shift count, PUSHF, divide error), সময় নেই।
  4. বাজারঘর board: flash 0x08000000, SRAM 0x20000000, ১ নির্দেশ = ১ cycle at 8 MHz; blink-এর LED 500.0054 ms-এ, LOAD = 7999. Timer-ভিত্তিক সময় আর ক্রম ভরসাযোগ্য, নির্দেশ-গোনা সময় নয়।
  5. rtos_sim tick ধরে scheduling দেখায় (inversion: H-এর response ১১ বনাম inheritance-এ ৫); mqtt_demo শুধু 127.0.0.1-এ, password আর TLS ছাড়া। আসল board-এ গেলে debug probe, bounce, noise আর বিদ্যুতের প্রশ্ন আসে।

পরের পর্বে: মডিউল ২ শুরু। 8085-এর ভেতরে ঢুকবেন: register, ALU, flag register-এর প্রতিটি বিট আর bus. যে flag byte (F = 54H) এই পর্বে বারবার দেখলেন, তার প্রতিটি বিট কোথা থেকে আসে, তা সেখানে।

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

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