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

8085 assembly program — loop, array, BCD আর গুণ-ভাগ

8085 Assembly Programming: Loops, Arrays, BCD, Multiplication and Division

Taught in Bangla, this lesson writes the classic 8085 programs from problem to flowchart, register plan, code and hand trace: 16-bit addition, block transfer, largest value, counting ones, multiplication by repeated addition and shift-add, division by repeated subtraction, BCD addition with DAA, and bubble sort. Every program runs in the course's 8085 simulator, and loop totals are expressed as T-state formulas such as 40N + 29. It ends with a 34-byte order-total program taking 271 T-states.

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

  • সমস্যা থেকে flowchart, register ভাগ, কোড আর হাতে trace — এই ক্রমে 8085 program লেখা
  • পরীক্ষার ক্লাসিক program (যোগ, ১৬ বিটের যোগ, block transfer, বড়-ছোট মান, 1 গোনা, গুণ, ভাগ, BCD যোগ, sort) নিজে লেখা আর ব্যাখ্যা করা
  • যেকোনো loop-এর মোট T-state একটি সূত্রে প্রকাশ করা আর ৩ MHz-এ সময় বের করা
  • DAA-র সংশোধনের নিয়ম আর carry দিয়ে বহু-byte যোগ বোঝা
  • শূন্য দিয়ে ভাগ, শূন্য গণক আর overlap-এর মতো লুকানো ভুল simulator-এ ধরা

১ · Program লেখার পদ্ধতি — সমস্যা থেকে trace পর্যন্ত

আগের চারটি পর্বে 8085-এর ভেতরটা দেখেছেন: register আর flag (পর্ব ০৭), machine cycle আর T-state (পর্ব ০৮), instruction-এর দল (পর্ব ০৯) আর addressing mode (পর্ব ১০)। সেগুলো ছিল শব্দ আর ব্যাকরণ। এই পর্বে বাক্য লেখা: সম্পূর্ণ program, যা একটি আসল সমস্যা সমাধান করে। প্রতিটি program কোর্সের 8085 simulator sim8085.py-এ চালানো (পর্ব ০৬-এ এর পরিচয়), আর পাতার প্রতিটি register-মান, memory-মান আর T-state সেই run থেকে নেওয়া।

উপমা — বাজারঘরের হিসাবরক্ষক: দিনের শেষে হিসাবরক্ষক খাতার পাতা ধরে এক লাইন করে পড়েন। আঙুল রাখেন বর্তমান লাইনে (pointer), মাথায় রাখেন আর কয়টি লাইন বাকি (গণক), আর ক্যালকুলেটরে চলতি যোগফল (accumulator). প্রতি লাইনে একই তিন কাজ: পড়া, হিসাবে যোগ করা, আঙুল এক লাইন নামানো। বাকি লাইন শূন্য হলে থামা। 8085-এর প্রায় সব array program ঠিক এই রকম: HL আঙুল, C গণক, A ক্যালকুলেটর।

লেখার নিয়ম এই পর্বজুড়ে: সব সংখ্যা Intel-এর ধরনে, শেষে H দিয়ে hex (2050H), অক্ষর দিয়ে শুরু হলে আগে 0 (0A7H), Spec decision 9 অনুযায়ী। Program শুরু 2000H-এ, data 2050H থেকে, ফল সাধারণত 2060H-এ। Clock ৩ MHz (৬ MHz crystal-এর অর্ধেক), তাই ১ T-state = ১/৩ µs ≈ 0.333 µs. T-state-এর মান Intel 8085 manual-এর টেবিল থেকে (Spec decision 2): JNZ/JC/JNC লাফ দিলে ১০ T, না দিলে ৭ T.

ভালো program পাঁচ ধাপে আসে। এক, সমস্যা আর data-র জায়গা ঠিক করা: কোথায় input, কোথায় output, কত byte. দুই, algorithm লেখা, সম্ভব হলে flowchart এঁকে। তিন, register ভাগ করা: কে pointer, কে গণক, কে ফল। চার, কোড। পাঁচ, ছোট data-য় dry run, তারপর simulator-এর trace দিয়ে মেলানো। নিচের ছবিতে array-র সবচেয়ে বড় মান খোঁজার flowchart, যা পরের অংশের একটি program.

ছবি ১১.১ — Array-র সবচেয়ে বড় মান: flowchart আর তার 8085 instruction

বাক্সের নিচের লেখা = সেই কাজের instruction; তীর = কাজের ক্রম

Array-র সবচেয়ে বড় মান খোঁজার flowchart শুরু HL ← 2050H, C ← গণনা A ← প্রথম মান, C ← C − 1 HL ← HL + 1 A < M ? A ← M (নতুন বড়) C ← C − 1 C = 0 ? [2060H] ← A থামা INX H CMP M MOV A,M DCR C JNZ STA 2060H হ্যাঁ (CY=1) না না হ্যাঁ
ছবি ১১.১ — নীল বাক্স কাজ, হলুদ হীরা সিদ্ধান্ত, সবুজ বাক্স শুধু শর্ত সত্য হলে চলে। বাঁ দিকের লম্বা তীরটিই loop: “C = 0?”-এর উত্তর “না” হলে আবার INX H-এ ফেরা। CMP M A থেকে M বিয়োগ করে শুধু flag বসায়; A < M হলে borrow, তাই CY = 1 (Spec decision 4).

Flowchart-এর প্রতিটি হীরা হয়ে যায় একটি flag-নির্ভর লাফ (conditional branch), আর প্রতিটি পিছনমুখী তীর একটি loop. এই loop-এর গণক C-কে বলা যায় loop counter: শুরুতে বাকি পাকের সংখ্যা, প্রতি পাকে DCR C, আর DCR C শূন্যে পৌঁছালে Z = 1 হয়, তাই JNZ পড়ে যায়। একটি সূক্ষ্ম কথা: DCR Z বসায় কিন্তু CY ছোঁয় না (Spec decision 4), তাই loop-এর ভেতরের যোগের carry গণকের কারণে মুছে যায় না। বাজারঘরের অর্ডারের program (অংশ ৮) এই সুবিধা কাজে লাগায়।

Register ভাগ করার সময় একটি স্থির অভ্যাস রাখলে program পড়া আর ভুল ধরা সহজ হয়। এই পর্বের সব program নিচের ভাগ মেনে চলে; পরীক্ষার খাতায়ও শুরুতে এমন একটি ছোট তালিকা লিখে রাখা ভালো, কারণ পরীক্ষক এক নজরে আপনার পরিকল্পনা বুঝতে পারেন।

Registerসাধারণ ভূমিকাকেন এটি
HLপ্রথম pointer (M)শুধু HL দিয়েই যেকোনো register আর ALU সরাসরি memory ছোঁয়
DEদ্বিতীয় pointer বা ১৬ বিটের মানLDAX D/STAX D, XCHG আর DAD D
CLoop counterDCR C Z বসায়, CY ছোঁয় না
Bঅস্থায়ী মান বা দ্বিতীয় গণকSwap, ভাজক, overflow-এর গণনা
AALU-র ফলসব ৮ বিটের যোগ, তুলনা আর logic A-তে হয়

২ · যোগ — carry ধরে রাখা আর ১৬ বিটের যোগ

প্রথম ক্লাসিক program: 2050H আর 2051H-এর দুটি byte যোগ করে যোগফল 2052H-এ, আর carry (০ বা ১) 2053H-এ। Reference lab-এর add2.asm হুবহু ব্যবহার করছি (Spec decision 2-এর T-state):

        ORG 2000H
START:  LDA 2050H       ; A <- প্রথম সংখ্যা        13 T
        MOV B,A         ;                          4 T
        LDA 2051H       ; A <- দ্বিতীয় সংখ্যা       13 T
        ADD B           ; A <- A + B, CY বসে       4 T
        STA 2052H       ; যোগফল                    13 T
        MVI A,00H       ; flag ছোঁয় না              7 T
        ACI 00H         ; A <- 0 + 0 + CY          7 T
        STA 2053H       ; carry                    13 T
        HLT             ;                          5 T

সত্যিকারের run (কোর্সের 8085 simulator, python -B sim8085.py run add2.asm, Python 3.13.5), data 49H আর 56H:

A=00 B=49 C=00 D=00 E=00 H=00 L=00 SP=0000 PC=2013
Flags: S=0 Z=1 AC=0 P=1 CY=0   (F=44H)
Memory 2050H..2053H:
  2050H: 49 56 9F 00
Instructions: 9   T-states: 79

49H + 56H = 9FH, carry নেই, তাই 2053H = 00. মূল কৌশলটি MVI A,00H তারপর ACI 00H: MVI কোনো flag বদলায় না, তাই ADD-এর CY তখনো বেঁচে থাকে, আর ACI 00H সেই CY-কে A-তে তুলে আনে। এখানে XRA A দিয়ে A শূন্য করলে চলত না, কারণ XRA CY মুছে দেয়। T-state হাতে যোগ: 13 + 4 + 13 + 4 + 13 + 7 + 7 + 13 + 5 = 79, ৩ MHz-এ প্রায় 26.33 µs. শেষের Z=1 দেখে ভুল বুঝবেন না: ওটি ACI-এর ফল শূন্য হওয়ার চিহ্ন, যোগফলের নয়।

১৬ বিটের যোগ দুইভাবে হয়। সহজ পথ DAD: HL ← HL + rp, এক instruction-এ পুরো ১৬ বিট, আর এটি শুধু CY বদলায়। Reference-এর add16.asm 1234H + 5678H করে:

        LHLD 2050H      ; HL <- 1234H            16 T
        XCHG            ; DE <- 1234H             4 T
        LHLD 2052H      ; HL <- 5678H            16 T
        DAD D           ; HL <- 68ACH, CY        10 T
        SHLD 2054H      ;                        16 T
        HLT             ;                         5 T
সত্যিকারের run:  2050H: 34 12 78 56 AC 68   Instructions: 6   T-states: 67

দ্বিতীয় পথ byte ধরে ধরে: নিচু byte-দুটি ADD, তারপর উঁচু byte-দুটি ADC (carry-সহ যোগ)। একে বলে multi-byte addition, আর এটিই ২৪ বা ৩২ বিটের যোগের একমাত্র পথ, কারণ DAD ১৬ বিটেই থামে। পর্ব ০৫-এর little-endian নিয়মে নিচু byte আগে বসে, তাই pointer এগোনোর সঙ্গে সঙ্গে carry-ও নিচ থেকে ওপরে যায়। অংশ ৮-এর অর্ডারের যোগ এই পথে। যোগের carry, overflow আর adder-এর hardware নিয়ে তত্ত্ব Computer Architecture পর্ব ২০-এ।

৩ · Loop আর array — block transfer, বড় আর ছোট মান

Block transfer (reference-এর block_move.asm): 2050H থেকে ৫টি byte 2060H-এ কপি। HL উৎস, DE গন্তব্য, C গণক:

        LXI H,2050H     ; উৎস                   10 T
        LXI D,2060H     ; গন্তব্য                10 T
        MVI C,05H       ; গণক                    7 T
LOOP:   MOV A,M         ;                        7 T
        STAX D          ;                        7 T
        INX H           ;                        6 T
        INX D           ;                        6 T
        DCR C           ;                        4 T
        JNZ LOOP        ; লাফ 10 T, শেষবার 7 T
        HLT             ;                        5 T
সত্যিকারের run:  2060H: 11 22 33 44 55   Instructions: 34   T-states: 229

T-state-এর সূত্র বের করার পদ্ধতিটি মুখস্থ রাখার মতো, কারণ পরীক্ষায় এটি বারবার আসে। Loop-এর আগে 10 + 10 + 7 = 27. প্রতি পাকে 7 + 7 + 6 + 6 + 4 + 10 = 40. শেষ পাকে JNZ লাফ দেয় না, তাই ৩ কম। শেষে HLT ৫. মোট = 27 + 40N − 3 + 5 = 40N + 29; N = 5-এ 229, simulator-এর সঙ্গে হুবহু। ৩ MHz-এ প্রায় 76.33 µs.

সবচেয়ে বড় মান (reference-এর largest.asm, ছবি ১১.১-এর flowchart): 2050H-এ গণনা ৫, তারপর 32H, A7H, 15H, C3H, 7EH. ফল 2060H-এ। নিচের stepper প্রতিটি পাকের শেষের অবস্থা দেখায়, সত্যিকারের trace থেকে (python -B sim8085.py trace largest.asm).

1LXI H,2050H2MOV C,M3INX H4MOV A,M5DCR C6LOOP: INX H7CMP M8JNC SKIP9MOV A,M10SKIP: DCR C11JNZ LOOP12STA 2060H13HLT
পাকের শেষে
HL
M
CMP-এর CY
A (বড়)
C
মোট T
  1. শুরুর পাঁচটি instruction, ৩৪ T. C = ৫ পড়া হলো, HL এগিয়ে প্রথম মানে, A = 32. প্রথম মানটি তুলনা ছাড়াই “এখন পর্যন্ত সবচেয়ে বড়”, তাই DCR C: বাকি তুলনা ৪টি।
  2. পাক ১: M = A7. CMP M করে 32 − A7: borrow লাগে, CY = 1. JNC লাফ দেয় না (৭ T), MOV A,M চলে: A = A7. এই পাকের খরচ 6 + 7 + 7 + 7 + 4 + 10 = 41 T, মোট ৭৫.
  3. পাক ২: M = 15. A7 − 15-এ borrow নেই, CY = 0. JNC লাফ দেয় (১০ T), MOV A,M বাদ পড়ে। A থাকে A7. খরচ 6 + 7 + 10 + 4 + 10 = 37 T, মোট ১১২.
  4. পাক ৩: M = C3. A7 < C3, CY = 1, তাই A = C3. আবার ৪১ T, মোট ১৫৩. CMP unsigned অর্থে তুলনা করে: C3H = ১৯৫, A7H = ১৬৭.
  5. পাক ৪: M = 7E, শেষ পাক. C3 > 7E, CY = 0, A বদলায় না। DCR C-এ C = 0, Z = 1, তাই JNZ লাফ দেয় না: ১০-এর জায়গায় ৭ T. খরচ ৩৪, মোট ১৮৭.
  6. STA 2060H (১৩ T) আর HLT (৫ T). 2060H-এ C3. Simulator-এর শেষ লাইন: Instructions: 29 T-states: 205. হাতে: 34 + 41 + 37 + 41 + 34 + 13 + 5 = 205.

খেয়াল করুন, মোট T-state data-র ওপর নির্ভর করে: যত বেশি বার “নতুন বড়” পাওয়া যায়, তত বেশি MOV A,M চলে। প্রতি পাকে খরচ ৩৭ বা ৪১ T (শেষ পাকে ৩ T কম)। Array ছোট থেকে বড় সাজানো থাকলে প্রতিটি পাকে নতুন বড় মান মেলে, তাই প্রতিটি ৪১ T; বড় থেকে ছোট সাজানো থাকলে একবারও না, প্রতিটি ৩৭ T.

সবচেয়ে ছোট মান খুঁজতে শুধু একটি লাফ বদলায়: JNC SKIP-এর জায়গায় JC SKIP, অর্থাৎ A < M হলে A-ই ছোট, কিছু করার নেই; নইলে MOV A,M. এই পর্বের lab-এ লেখা smallest.asm একই data-য় চালানো হলো (সত্যিকারের run): 2060H: 15, Instructions: 28 T-states: 201. একটি নির্দেশ কম, কারণ এবার “নতুন” মান পাওয়া গেছে একবারই (15H). সমান মানের বেলায় দুটি program-ই আগেরটি রাখে বা নতুনটি নেয়, কিন্তু মান একই হওয়ায় ফল বদলায় না।

৪ · বিট গোনা আর গুণ — rotate, বারবার যোগ আর shift-add

একটি byte-এ কয়টি 1: এই হিসাবের নাম popcount. পদ্ধতি: আটবার RRC (rotate), প্রতিবার বিট ০ CY-তে যায়; CY = 1 হলে গণক বাড়ানো। এই পর্বের lab-এর count1s.asm:

        LDA 2050H
        MVI B,00H       ; B <- 1-এর গণনা
        MVI C,08H       ; ৮টি বিট
LOOP:   RRC             ; CY <- বিট 0
        JNC SKIP
        INR B
SKIP:   DCR C
        JNZ LOOP
        MOV A,B
        STA 2051H
        HLT
সত্যিকারের run (2050H = A7H = 1010 0111):
  2050H: A7 05   Instructions: 43   T-states: 275

ফল ৫, ঠিক। RRC আটবার ঘোরালে A আবার আগের মানে ফেরে, তাই এটি data নষ্ট করে না; RAR হলে CY-ও চক্রে ঢুকত আর আটবারে A ফেরত আসত না। INR B CY ছোঁয় না, এটাও কাজে লাগে। সময়ের সূত্রটিও সুন্দর: শুরুতে 13 + 7 + 7 = 27 T; যে বিট 0, তার পাক RRC 4 + JNC লাফ 10 + DCR 4 + JNZ 10 = 28 T; যে বিট 1, তার পাকে JNC লাফ দেয় না (৭) আর INR B (৪) যোগ হয়, তাই 29 T; শেষ পাকে ৩ কম; শেষে 4 + 13 + 5 = 22. মোট = 27 + 28 × 8 + k − 3 + 22 = 270 + k, যেখানে k হলো 1-বিটের সংখ্যা। A7H-এ k = 5, তাই ২৭৫, simulator-এর সঙ্গে হুবহু। অর্থাৎ program-এর সময় নিজেই উত্তরটি “ফাঁস” করে দেয়; এই ধারণা ভাবনার প্রশ্ন ৩-এ আবার আসবে।

গুণ, বারবার যোগ করে: 8085-এর instruction set-এ গুণ নেই। সবচেয়ে সরল পথ: a × b = a-কে b বার যোগ। Reference-এর multiply.asm ৮ বিটের দুটি সংখ্যার ১৬ বিটের গুণফল বানায়: DE-তে গুণ্য, C-তে গুণক, HL-এ ফল, আর প্রতি পাকে DAD D. গুণক শূন্য নয়, এটি program-এর precondition; শর্ত ভাঙলে কী হয়, তা অনুশীলন ২-এ।

1LDA 2050H2MOV E,A3MVI D,00H4LDA 2051H5MOV C,A6LXI H,0000H7LOOP: DAD D8DCR C9JNZ LOOP10SHLD 2052H11HLT
Register আর memory
DE
HL
দশমিকে
C
2052H
মোট T
  1. প্রস্তুতি, ৫১ T. 2050H থেকে C8H (= ২০০) E-তে, D = 00, তাই DE = 00C8H. 2051H থেকে 05 C-তে। HL = 0000H. গুণ্যকে ১৬ বিটে নেওয়া জরুরি, কারণ ফল ২৫৫ ছাড়াবে।
  2. পাক ১. DAD D (১০ T): HL = 00C8H = ২০০. DCR C (৪ T): C = 4. JNZ লাফ (১০ T). প্রতি পাকে ২৪ T, মোট ৭৫.
  3. পাক ২. HL = 0190H = ৪০০, C = 3, মোট ৯৯. DAD শুধু CY বদলায়; Z বসায় DCR C, তাই loop-এর শর্ত গণকের ওপরই নির্ভর করে।
  4. পাক ৩. HL = 0258H = ৬০০, C = 2, মোট ১২৩.
  5. পাক ৪. HL = 0320H = ৮০০, C = 1, মোট ১৪৭.
  6. পাক ৫, শেষ. HL = 03E8H = ১০০০. C = 0, Z = 1, JNZ লাফ দেয় না (৭ T): পাকের খরচ ২১, মোট ১৬৮.
  7. SHLD 2052H (১৬ T) আর HLT (৫ T), মোট ১৮৯. 2052H-এ E8, 2053H-এ 03: ছোট byte আগে। সূত্র: 51 + 24b − 3 + 16 + 5 = 69 + 24b; b = 5-এ ১৮৯, reference README-র হিসাবের সঙ্গে মেলে।

বারবার যোগের সমস্যা স্পষ্ট: সময় গুণকের সমানুপাতিক। b = 200 হলে ৪৮৬৯ T, প্রায় 1.6 ms. হাতে দশমিক গুণের মতো পথটি দ্রুত: গুণকের প্রতিটি বিট দেখা, ফলকে দ্বিগুণ করা (shift), আর বিট 1 হলে গুণ্য যোগ করা। একে বলে shift-and-add গুণ। 8085-এ DAD H মানে HL + HL = HL × 2, আর RAL গুণকের বড় বিটটি CY-তে আনে। এই পর্বের lab-এর mulsa.asm-এর loop:

        MVI C,08H       ; ৮টি বিট
LOOP:   DAD H           ; HL <- 2 x HL
        RAL             ; CY <- গুণকের পরের বিট (বড়টি আগে)
        JNC SKIP
        DAD D           ; বিট 1: গুণ্য যোগ
SKIP:   DCR C
        JNZ LOOP
সত্যিকারের run (200 x 5):  2050H: C8 05 E8 03   Instructions: 50   T-states: 390

200 × 5-এ shift-add ধীর (৩৯০ বনাম ১৮৯ T), কারণ সে সবসময় আটটি পাক ঘোরে। কিন্তু তার সময় গুণকের মানের ওপর নয়, গুণকের কয়টি বিট 1 তার ওপর নির্ভর করে। নিচের ব্লক দুটি program-কে কয়েক জোড়া সংখ্যায় চালায়, কোর্সের simulator-এর পাতার ভেতরের কপি sim85.py দিয়ে (reference-এর sim8085.py-এর হুবহু রূপ; এই পর্বের ২১টি program-এর run আর trace মিলিয়ে ৪২টি আউটপুট দুটিতে অক্ষরে অক্ষরে এক)।

# একই গুণ দুই পদ্ধতিতে: বারবার যোগ বনাম shift-add (sim85.py দিয়ে চালানো)
from sim85 import assemble, run

REPEAT = """LDA 2050H / MOV E,A / MVI D,00H / LDA 2051H / MOV C,A
          / LXI H,0000H / LOOP: DAD D / DCR C / JNZ LOOP / SHLD 2052H / HLT"""
SHIFT = """LDA 2050H / MOV E,A / MVI D,00H / LDA 2051H / LXI H,0000H
         / MVI C,08H / LOOP: DAD H / RAL / JNC SKIP / DAD D
         / SKIP: DCR C / JNZ LOOP / SHLD 2052H / HLT"""

def go(src, a, b):
    lines = ["  ORG 2000H"] + ["  " + x.strip() for x in src.split("/")]
    cpu = run(assemble("\n".join(lines)), sets=[(0x2050, [a, b])])
    return cpu.mem[0x2052] | cpu.mem[0x2053] << 8, cpu.tstates

print("  a x   b | গুণফল | repeat T | shift-add T | b-তে 1")
for a, b in [(200, 5), (200, 1), (13, 50), (200, 200), (255, 255)]:
    p1, t1 = go(REPEAT, a, b)
    p2, t2 = go(SHIFT, a, b)
    assert p1 == p2 == a * b
    print(f"{a:3} x {b:3} | {p1:5} | {t1:8} | {t2:11} | {bin(b).count('1')}")

first = next(b for b in range(1, 256) if go(REPEAT, 200, b)[1] > go(SHIFT, 200, b)[1])
print("shift-add প্রথম দ্রুত হয় b =", first, "থেকে")

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

  a x   b | গুণফল | repeat T | shift-add T | b-তে 1
200 x   5 |  1000 |      189 |         390 | 2
200 x   1 |   200 |       93 |         383 | 1
 13 x  50 |   650 |     1269 |         397 | 3
200 x 200 | 40000 |     4869 |         397 | 3
255 x 255 | 65025 |     6189 |         432 | 8
shift-add প্রথম দ্রুত হয় b = 14 থেকে

বারবার যোগ = 69 + 24b, আর shift-add = 376 + 7k, যেখানে k = গুণকের 1-বিটের সংখ্যা (প্রতিটি 1-বিট JNC-এর ৭ আর DAD D-এর ১০, মোট ১৭ T নেয়; 0-বিট শুধু ১০ T). দুই সূত্রই এই পর্বের lab-এ b = 1 থেকে 255 পর্যন্ত সব মানে simulator-এর সঙ্গে মিলেছে। 13 × 50 আর 200 × 200-এর shift-add সময় সমান (৩৯৭), কারণ 50 = 0011 0010 আর 200 = 1100 1000, দুটিতেই তিনটি 1. তাই গুণের আগে বড়-ছোট বেছে নেওয়ার কৌশল বারবার যোগে খুব কাজে লাগে (13 × 50-কে 50 × 13 লিখলে ১২৬৯ থেকে ৩৮১ T), কিন্তু shift-add-এ নয়। Hardware multiplier এই shift-add-ই সমান্তরালে করে; সেই তত্ত্ব Computer Architecture পর্ব ২১-এ।

৫ · ভাগ — বারবার বিয়োগ, ভাগফল আর ভাগশেষ

ভাগের instruction-ও নেই। সরল পথ: ভাজ্য থেকে ভাজক যতবার বিয়োগ করা যায়, সেটিই ভাগফল, আর যা বাকি থাকে তা ভাগশেষ। একে বলে repeated subtraction. Reference-এর divide.asm:

        LDA 2051H
        MOV B,A         ; B <- ভাজক
        LDA 2050H       ; A <- ভাজ্য
        MVI C,00H       ; C <- ভাগফল
LOOP:   CMP B
        JC DONE         ; A < B হলে শেষ
        SUB B
        INR C
        JMP LOOP
DONE:   STA 2053H       ; ভাগশেষ
        MOV A,C
        STA 2052H       ; ভাগফল
        HLT
সত্যিকারের run (100 ÷ 7):
  2050H: 64 07 0E 02   Instructions: 80   T-states: 492

100 ÷ 7 = 14 (0EH), ভাগশেষ 2. এই loop-এ গণক নেই; থামার শর্ত data নিজেই: CMP B-এ A < B হলে CY = 1 আর JC DONE. সময়ের সূত্র: শুরুতে 13 + 4 + 13 + 7 = 37; প্রতিটি সফল বিয়োগে CMP 4 + JC না-লাফ 7 + SUB 4 + INR 4 + JMP 10 = 29; শেষ তুলনায় 4 + 10 = 14; শেষের চারটি instruction 13 + 4 + 13 + 5 = 35. মোট = 86 + 29q, যেখানে q ভাগফল: 86 + 29 × 14 = 492. সূত্রটি lab-এ 10 ÷ 3 (১৭৩ T), 255 ÷ 1 (৭৪৮১ T) আর 5 ÷ 9 (৮৬ T, ভাগফল 0) দিয়েও মেলানো হয়েছে। 255 ÷ 1-এর ৭৪৮১ T মানে প্রায় 2.5 ms: ছোট ভাজকে এই পদ্ধতি খুব ধীর।

শূন্য দিয়ে ভাগ: ভাজক 0 হলে CMP B কখনো borrow দেয় না, তাই loop থামেই না, একটি infinite loop; C শুধু 00 থেকে FF ঘুরে আবার 00 হয়। 8085-এ কোনো “divide error” নেই, কারণ ভাগের instruction-ই নেই। কোর্সের simulator এই program-কে ভাজক 0 দিয়ে চালালে থামে এই বার্তায়: runtime error: stopped after 1000000 instructions (no HLT reached?) (Spec decision 11). আসল chip-এ কোনো বার্তা আসে না, যন্ত্র শুধু আটকে থাকে। তাই শুরুতে ভাজক পরীক্ষা (MOV A,B, ORA A, JZ ERROR) ভালো অভ্যাস। 8086-এ DIV আছে, আর শূন্যে ভাগ করলে CPU নিজে interrupt 0 তোলে; সেটি পর্ব ২০ (8086-এর interrupt)-এ।

৬ · BCD যোগ আর DAA — দশমিক অঙ্কের সংশোধন

বাজারঘরের দাঁড়িপাল্লার display-এ সংখ্যা দেখাতে প্রতিটি দশমিক অঙ্ক আলাদা লাগে। BCD-তে একটি byte-এ দুটি দশমিক অঙ্ক থাকে, প্রতিটি ৪ বিটে: ৭৫ লেখা হয় 75H. একে বলে packed BCD (পর্ব ০৫-এ পরিচয়)। সমস্যা হলো ALU binary-তে যোগ করে: 75H + 48H = BDH, যা BCD-তে অর্থহীন (B আর D কোনো দশমিক অঙ্ক নয়)। DAA (Decimal Adjust Accumulator) এই ফল ঠিক করে। Spec decision 5-এর নিয়ম, Intel 8085 manual অনুযায়ী:

  • নিচের nibble ৯-এর বেশি, অথবা AC = 1 হলে 06H যোগ।
  • ওপরের nibble ৯-এর বেশি, অথবা CY = 1, অথবা (ওপরের nibble ≥ ৯ আর নিচেরটি ৯-এর বেশি) হলে 60H যোগ, আর CY = 1.

কেন ৬? চার বিটে ১৬টি মান, দশমিকে লাগে ১০টি; ৬টি মান “অপচয়”। ৯-এর বেশি হলে ৬ যোগ করলে ঘরটি সেই ছয়টি অব্যবহৃত মান লাফিয়ে পার হয়, আর carry পরের অঙ্কে যায়। নিচের stepper reference-এর bcd_add.asm-এর সত্যিকারের trace: 75 + 48 = 123.

1LDA 2050H2MOV B,A3LDA 2051H4ADD B5DAA6STA 2052H7MVI A,00H8RAL9STA 2053H10HLT
A, flag আর memory
A
সংশোধন
S Z AC P CY
2052H 2053H
মোট T
  1. দুটি BCD সংখ্যা আনা, ৩০ T. B = 75, A = 48. কোনো flag বদলায়নি, কারণ LDA আর MOV flag ছোঁয় না।
  2. ADD B, ৪ T. 75H + 48H = BDH. নিচের nibble 5 + 8 = D, ১৫-এর বেশি নয়, তাই AC = 0; মোট FFH ছাড়ায়নি, তাই CY = 0. S = 1 কারণ বিট ৭ = 1, P = 1 কারণ BDH-এ ছয়টি 1.
  3. DAA-র প্রথম পরীক্ষা. নিচের nibble D (১৩) > ৯, তাই সংশোধনে 06H থাকবে। এটি আলাদা কোনো instruction নয়: DAA একটিই ৪ T-এর instruction, এখানে বোঝার সুবিধার জন্য তার দুটি পরীক্ষা আলাদা দেখানো হলো।
  4. DAA-র দ্বিতীয় পরীক্ষা, মোট ৩৮ T. ওপরের nibble B (১১) > ৯, তাই 60H-ও যোগ হবে: সংশোধন 66H. BDH + 66H = 123H, A = 23, CY = 1 (শতকের অঙ্ক)। AC = 1, কারণ D + 6 নিচের nibble থেকে carry দেয়।
  5. STA 2052H, ১৩ T. দশক আর একক অঙ্ক 23 memory-তে। CY এখনো 1, কারণ STA flag ছোঁয় না।
  6. MVI A,00H তারপর RAL, মোট ৬২ T. RAL A-কে বাঁয়ে ঘোরায় আর পুরোনো CY বিট ০-তে বসায়: A = 01. নতুন CY = A-র পুরোনো বিট ৭ = 0.
  7. STA 2053H আর HLT, মোট ৮০ T. Memory: 2050H: 75 48 23 01, অর্থাৎ ১২৩. Simulator: Instructions: 10 T-states: 80, (F=10H).

AC-এর ভূমিকা দেখতে আরেকটি উদাহরণ (এই পর্বের lab-এর bcd2.asm, সত্যিকারের run): 38H + 29H = 61H. নিচের nibble 1 দেখতে ঠিকঠাক, কিন্তু 8 + 9 = 17, অর্থাৎ নিচের nibble থেকে carry গেছে: AC = 1. তাই DAA 06H যোগ করে 67H দেয়, আর ৩৮ + ২৯ = ৬৭ ঠিক। ফল 2050H: 38 29 67, ৫৬ T. AC না থাকলে এই ভুল ধরার কোনো উপায় থাকত না; 8085-এ AC flag-এর প্রায় একমাত্র ব্যবহারকারী DAA.

DAA 8085-এর নিজের আবিষ্কার নয়: ১৯৭৪ সালের 8080-এ এটি ছিল, আর 8085 (১৯৭৬) তা হুবহু রেখেছে, AC flag-সহ। সেই যুগে মাপার যন্ত্র, ক্যাশ রেজিস্টার আর trainer kit-এর display প্রায়ই দশমিক অঙ্কে কাজ করত, তাই একটি ৪ T-এর instruction-এ দশমিক সংশোধন বড় সুবিধা ছিল। ১৯৭৬ সালের Z80 একটি বাড়তি N flag রেখে বিয়োগের পরেও DAA চালানোর ব্যবস্থা করে, আর ১৯৭৮ সালের 8086 বিয়োগের জন্য আলাদা DAS আর আলাদা-অঙ্কের (unpacked) BCD-র জন্য AAA, AAS যোগ করে। 8086-এর instruction set পর্ব ১৬-এর বিষয়।

নিয়মটি সব ক্ষেত্রে ঠিক কি না, নিচের ব্লক তা পরীক্ষা করে: Python-এ নিয়মটি লিখে ০০ থেকে ৯৯-এর সব জোড়া (১০,০০০টি) যোগ করে দশমিক উত্তরের সঙ্গে মেলায়। এই পর্বের lab-এ একই ১০,০০০ জোড়া কোর্সের simulator-এ ADD + DAA চালিয়েও মেলানো হয়েছে: ০টি অমিল।

# DAA-র নিয়ম (Spec decision 5) হাতে লেখা, তারপর 0..99 + 0..99-এর সব জোড়ায় যাচাই
def add(a, b):                       # ADD: ৮ বিটের যোগফল, CY, AC
    s = a + b
    return s & 0xFF, s > 0xFF, (a & 0x0F) + (b & 0x0F) > 0x0F

def daa(a, cy, ac):
    lo, hi = a & 0x0F, a >> 4
    corr = 0
    if lo > 9 or ac:
        corr |= 0x06
    if hi > 9 or cy or (hi >= 9 and lo > 9):
        corr |= 0x60
        cy = True
    return (a + corr) & 0xFF, cy, corr

def bcd(n):                          # 75 -> 75H
    return (n // 10) << 4 | n % 10

ok = 0
for x in range(100):
    for y in range(100):
        r, cy, ac = add(bcd(x), bcd(y))
        a, cy, _ = daa(r, cy, ac)
        ok += (a == bcd((x + y) % 100) and cy == (x + y > 99))
print("ঠিক জোড়া:", ok, "/ 10000")

for x, y in [(75, 48), (38, 29), (45, 23), (99, 99)]:
    r, cy, ac = add(bcd(x), bcd(y))
    a, cy2, corr = daa(r, cy, ac)
    print(f"{x}+{y}: ADD -> {r:02X}H CY={cy:d} AC={ac:d} | DAA +{corr:02X}H -> {a:02X}H CY={cy2:d}")

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

ঠিক জোড়া: 10000 / 10000
75+48: ADD -> BDH CY=0 AC=0 | DAA +66H -> 23H CY=1
38+29: ADD -> 61H CY=0 AC=1 | DAA +06H -> 67H CY=0
45+23: ADD -> 68H CY=0 AC=0 | DAA +00H -> 68H CY=0
99+99: ADD -> 32H CY=1 AC=1 | DAA +66H -> 98H CY=1

চারটি সারি চার রকম পরিস্থিতি: দুই nibble-ই বড় (75 + 48), শুধু AC (38 + 29), কোনো সংশোধন নয় (45 + 23), আর CY ও AC দুটোই (99 + 99 = 198: binary যোগ 132H, A = 32H, CY = 1; সংশোধনের পরে 98H আর CY = 1, অর্থাৎ ১৯৮)। শেষটি দেখায় কেন CY-ও নিয়মের অংশ: 32H দেখতে বৈধ BCD, কিন্তু আসলে ভুল। একটি সীমা মনে রাখুন: 8085-এর DAA শুধু যোগের পরে ঠিক কাজ করে। BCD বিয়োগ করতে সাধারণত ভাজকের দশমিক complement (৯৯ − x + ১) যোগ করা হয়। 8086-এ বিয়োগের জন্য আলাদা DAS আছে।

৭ · Bubble sort — loop-এর ভেতরে loop

সাজানোর program পরীক্ষার সবচেয়ে বড় প্রশ্নগুলোর একটি, কারণ এতে একসঙ্গে দুটি loop, তুলনা, শর্তযুক্ত লাফ আর memory-তে জায়গা বদল লাগে। Bubble sort-এ পাশাপাশি দুটি মান উল্টো ক্রমে থাকলে জায়গা বদল হয়; প্রতি pass-এ বাকিদের সবচেয়ে বড়টি শেষে চলে যায়। এটি একটি nested loop: বাইরের loop n − 1টি pass গোনে (C), ভেতরের loop প্রতি pass-এ তুলনা গোনে (D). Reference-এর sort.asm-এ একটি সুবিধাজনক সরলতা আছে: প্রতি pass-এ তুলনার সংখ্যা D = C, তাই প্রথম pass-এ ৪টি, তারপর ৩, ২, ১টি; শেষে যে মানগুলো আগেই জায়গামতো বসেছে, সেগুলো আর ছোঁয়া হয় না।

জায়গা বদলের অংশটি খেয়াল করুন: MOV A,M, INX H, CMP M দিয়ে A-তে a[i] আর M-এ a[i+1]. বদল দরকার হলে MOV B,M (B ← a[i+1]), MOV M,A (a[i+1] ← a[i]), DCX H, MOV M,B (a[i] ← পুরোনো a[i+1]), INX H. সমান হলে বদল নয় (JZ NOSWAP), তাই সমান মানের ক্রম অপরিবর্তিত থাকে। নিচের ব্লক program-টি চালায় আর প্রতি pass-এর শেষে array দেখায়; এর জন্য simulator-এর trace hook ব্যবহার করা হয়েছে, program নিজে বদলানো হয়নি।

# Bubble sort: প্রতিটি pass-এর পরে array, swap আর T-state (sim85.py-র trace hook)
from sim85 import assemble, run

SRC = """        ORG 2000H
        LXI H,2050H
        MOV C,M         ; C <- n
        DCR C           ; n-1টি pass
OUTER:  MOV D,C         ; D <- এই pass-এ তুলনা
        LXI H,2051H
INNER:  MOV A,M
        INX H
        CMP M           ; a[i] বনাম a[i+1]
        JC NOSWAP
        JZ NOSWAP
        MOV B,M         ; swap
        MOV M,A
        DCX H
        MOV M,B
        INX H
NOSWAP: DCR D
        JNZ INNER
        DCR C
        JNZ OUTER
        HLT"""
prog = assemble(SRC)
END = prog.symbols["NOSWAP"] + 4                 # বাইরের DCR C-এর ঠিকানা
st = {"t0": 0, "sw": 0, "n": 0}
def hook(cpu, pc, op, cost):
    st["sw"] += op == 0x70                       # MOV M,B = একটি swap শেষ
    if pc == END:
        st["n"] += 1
        print(f"pass {st['n']}: {cpu.mem[0x2051:0x2056].hex(' ').upper()}  swap={st['sw']}  T={cpu.tstates - st['t0']}")
        st["t0"], st["sw"] = cpu.tstates, 0
cpu = run(prog, sets=[(0x2050, [5, 0x32, 0xA7, 0x15, 0xC3, 0x7E])], trace=hook)
print(f"শেষে JNZ (লাফ নেই) + HLT = {cpu.tstates - st['t0']} T\nমোট T-state = {cpu.tstates}, instruction = {cpu.steps}")

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

pass 1: 32 15 A7 7E C3  swap=2  T=286
pass 2: 15 32 7E A7 C3  swap=2  T=231
pass 3: 15 32 7E A7 C3  swap=0  T=113
pass 4: 15 32 7E A7 C3  swap=0  T=69
শেষে JNZ (লাফ নেই) + HLT = 12 T
মোট T-state = 711, instruction = 104

মোট ৭১১ T, reference README-র pass ধরে হাতে মেলানো হিসাবের সঙ্গে এক (pass 1-এর ২৮৬-এর মধ্যে শুরুর তিনটি instruction-এর ২১ T আছে)। শুরুর array 32 A7 15 C3 7E. Pass 1-এ দুটি বদল (A7↔15, C3↔7E), আর সবচেয়ে বড় C3 শেষে পৌঁছায়। Pass 2-এর পরেই array সাজানো, তবু pass 3 আর 4 চলে, কারণ এই program জানে না যে কোনো বদল হয়নি। একটি “বদল হয়েছে কি না” flag (যেমন E register) রেখে কোনো বদল ছাড়া pass শেষ হলে থামলে এখানে ১৮২ T (১১৩ + ৬৯) বাঁচত, তবে প্রতিটি বদলে flag বসানোর খরচ যোগ হতো। সাজানোর algorithm-এর তুলনা আর জটিলতা DSA পর্ব ২০-এ।

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

  • দুটি ৮ বিটের সংখ্যা যোগ করে carry-সহ রাখার program লিখুন। ADD-এর পরে MVI A,00H আর ACI 00H; ৯টি instruction, ৭৯ T.
  • Block transfer-এর মোট T-state কত (N byte)? 27 + 40N − 3 + 5 = 40N + 29; N = 5-এ ২২৯ T, ৩ MHz-এ প্রায় 76.33 µs.
  • DAA কখন 06H আর কখন 60H যোগ করে? নিচের nibble ৯-এর বেশি বা AC = 1 হলে 06H; ওপরের nibble ৯-এর বেশি বা CY = 1 হলে (বা নিচের সংশোধনে ওপরেরটি ৯ ছাড়ালে) 60H.
  • 8085-এ গুণ কীভাবে করবেন? বারবার যোগ (69 + 24b T) বা shift-add (DAD H, RAL; ৮টি পাক); 8085-এ MUL নেই।
  • Array-র সবচেয়ে বড় মান খুঁজতে কোন flag দেখবেন? CMP M-এর পরে CY: CY = 1 মানে A < M, তাই নতুন বড় মান।

৮ · বাজারঘরের অর্ডারের মোট দাম — সব কৌশল একসঙ্গে

বাজারঘরের smart scale-এ (reference README, “বাজারঘর devices”) একজন ক্রেতা তিনবার আলু ওজন করালেন: ১৫০ g (দাম ৯৮৩ পয়সা = ৯.৮৩ টাকা), ১২৫০ g (৮১৮৮ পয়সা = ৮১.৮৮ টাকা) আর ৫০০ g (৩২৭৫ পয়সা = ৩২.৭৫ টাকা), প্রতিটি ৬৫.৫০ টাকা/kg হারে। এখন রসিদের মোট দাম চাই। পয়সায় হিসাব করলে দশমিক বিন্দুর ঝামেলা নেই, আর তিনটি দামই ২৫৫-এর বেশি, তাই প্রতিটি ১৬ বিটের word, ছোট byte আগে: 983 = 03D7H → D7 03, 8188 = 1FFCH → FC 1F, 3275 = 0CCBH → CB 0C.

Register ভাগ: HL pointer, C item-এর সংখ্যা, DE চলতি মোট, B overflow-এর গণক। প্রতি item-এ নিচু byte ADD E, উঁচু byte ADC D: অংশ ২-এর multi-byte addition. ADC-এর পরে CY = 1 মানে মোট ৬৫৫৩৫ পয়সা ছাড়িয়েছে, তাই INR B. মাঝের INX H, MOV আর DCR C কেউই CY বদলায় না (INX কোনো flag ছোঁয় না), তাই নিচু byte-এর carry নিরাপদে উঁচু byte পর্যন্ত পৌঁছায়। নিচের ব্লকটি নিজে বদলে চালাতে পারবেন: ;@set লাইনে দাম বদলান, বা শেষ লাইনে "trace" লিখুন।

# বাজারঘরের অর্ডারের মোট দাম: কোর্সের simulator-এর কপি (sim85.py) দিয়ে চালানো
from sim85 import cli

SRC = """
;@set 2050H 03H,0D7H,03H,0FCH,1FH,0CBH,0CH
;@show 2060H 3
        ORG 2000H
        LXI H,2050H
        MOV C,M         ; C <- কয়টি item
        LXI D,0000H     ; DE <- মোট দাম (paisa)
        MVI B,00H       ; B <- overflow-এর গণনা
NEXT:   INX H
        MOV A,M         ; দামের নিচু byte
        ADD E
        MOV E,A
        INX H
        MOV A,M         ; দামের উঁচু byte
        ADC D           ; + নিচু byte-এর carry
        MOV D,A
        JNC OK
        INR B           ; মোট FFFFH ছাড়িয়েছে
OK:     DCR C
        JNZ NEXT
        XCHG
        SHLD 2060H      ; মোট, ছোট byte আগে
        MOV A,B
        STA 2062H
        HLT
"""
cli(SRC)        # cli(SRC, "trace") লিখলে প্রতিটি নির্দেশের পরের অবস্থা দেখাবে

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

A=00 B=00 C=00 D=20 E=56 H=30 L=9E SP=0000 PC=2022
Flags: S=0 Z=1 AC=1 P=1 CY=0   (F=54H)
Memory 2060H..2062H:
  2060H: 9E 30 00
Instructions: 42   T-states: 271

মোট 309EH = ১২৪৪৬ পয়সা = ১২৪.৪৬ টাকা, overflow 0. আউটপুট কোর্সের sim8085.py run order.asm-এর সঙ্গে অক্ষরে অক্ষরে এক। শেষে DE = 2056H দেখে অবাক হবেন না: XCHG মোটকে HL-এ আর পুরোনো pointer-কে DE-তে পাঠিয়েছে, যাতে SHLD দিয়ে এক instruction-এ ১৬ বিট রাখা যায়। দ্বিতীয় item-এ trace দেখায় নিচু byte D7 + FC = 1D3H: A = D3, CY = 1; তারপর ADC D: 1F + 03 + 1 = 23. এই এক বিটের carry হারালে মোট ২৫৬ পয়সা, অর্থাৎ ২.৫৬ টাকা কম হতো।

T-state হাতে: শুরু 10 + 7 + 10 + 7 = 34; প্রতি item 6 + 7 + 4 + 4 + 6 + 7 + 4 + 4 + 10 + 4 + 10 = 66 (শেষটিতে ৬৩); শেষের পাঁচটি 4 + 16 + 4 + 13 + 5 = 42. মোট 34 + 66 + 66 + 63 + 42 = 271, প্রায় 90.33 µs. পাঁচটি ২০০ টাকার item (প্রতিটি 4E20H) দিয়ে lab-এ চালালে মোট ১,০০,০০০ পয়সা ১৬ বিটে আঁটে না: ফল 2060H: A0 86 01, অর্থাৎ নিচের ১৬ বিট 86A0H (৩৪৪৬৪) আর overflow 1, ৪০৪ T.

এই পর্বের সব program এক টেবিলে; byte আর T-state কোর্সের simulator থেকে, “নিজের” মানে এই পর্বের lab-এ লেখা, বাকিগুলো reference lab-এর:

ProgramData → ফলByteT-stateসূত্র
add249 + 56 → 9F, carry 001979স্থির
add161234H + 5678H → 68ACH1267স্থির
block_move৫ byte, 2050H → 2060H1722940N + 29
largest32 A7 15 C3 7E → C321205data-নির্ভর
smallest (নিজের)একই data → 1521201data-নির্ভর
count1s (নিজের)A7H → 521275k-নির্ভর
multiply200 × 5 → 03E8H2218969 + 24b
mulsa (নিজের)200 × 5 → 03E8H28390376 + 7k
divide100 ÷ 7 → 14, ভাগশেষ 22649286 + 29q
bcd_add75 + 48 → 23, 011980স্থির
sort→ 15 32 7E A7 C332711data-নির্ভর
order (নিজের)983 + 8188 + 3275 → 309EH3427166n + 73

আরও গভীরে: 8085-এর ALU-তে গুণ-ভাগের কোনো hardware নেই; ১৯৭৮ সালের 8086 MUL আর DIV আনে, কিন্তু ভেতরে microcode দিয়ে ধাপে ধাপে, তাই সেগুলো তার অন্য instruction-এর চেয়ে অনেক বেশি clock নেয় (Intel-এর 8086 manual-এর টেবিলে)। আধুনিক microcontroller-এ ছবিটি আলাদা: ARM-এর Cortex-M3 Technical Reference Manual অনুযায়ী Cortex-M3-এ ৩২ বিটের গুণ এক cycle-এ আর hardware ভাগ কয়েক cycle-এ হয়, কিন্তু ছোট Cortex-M0-এ ভাগের instruction নেই, তাই compiler সেখানে ভাগকে একটি library function-এ পাঠায়, যা এই পর্বের মতোই বিয়োগ আর shift-এর loop. AVR-এর ATmega328P-তে ৮ বিটের hardware গুণ আছে, ভাগ নেই। অর্থাৎ এই পর্বের “হাতে গুণ-ভাগ” আজও কোনো না কোনো library-র ভেতরে চলছে।

৯ · AI-এর যুগে 8085 program যাচাই

AI assistant-কে “8085-এ bubble sort লিখে দিন” বললে কয়েক সেকেন্ডে কোড আসে, আর দেখতে প্রায় সবসময় বিশ্বাসযোগ্য। কিন্তু 8085 program-এর ভুল সাধারণত এক লাইনের: ভুল flag, ভুল লাফ, ভুল T-state. এগুলো চোখে পড়ে না, পড়ে simulator-এ।

AI প্রায়ই যা করেকীভাবে ধরবেন
Z80 বা 8086-এর instruction মেশানো: DJNZ, LD A,(HL), MUL, LOOPকোর্সের simulator-এ assemble; Intel 8085 manual-এর তালিকা
DCX B দিয়ে ১৬ বিটের গণক কমিয়ে JNZ: DCX কোনো flag বসায় না, তাই loop ভুল চলেTrace-এ flag-এর ঘর দেখুন; সঠিক রূপ DCX B, MOV A,C, ORA B, JNZ (পর্ব ১২-এর delay loop)
বড় মান খুঁজতে JC আর JNC উল্টো, বা signed তুলনায় CMP-এর CY ব্যবহারছোট data-য় dry run; উল্টো সাজানো আর সমান মানের array দিয়ে simulator-এ চালান
বিয়োগের পরে DAA ব্যবহার, বা AC-এর শর্ত বাদ দেওয়া38 + 29 আর 99 + 99-এর মতো ধারালো উদাহরণ চালান
ভুল মোট T-state: শেষ JNZ-এর ৭ T ভুলে যাওয়া, INX-কে ৪ T ধরাSimulator-এর T= আর total=; সূত্র বানিয়ে দুই আকারের data-য় মেলান
গুণক বা ভাজক শূন্য, overlap-এর মতো সীমার অবস্থা উপেক্ষা0, 1, 255 আর overlap-সহ data দিয়ে চালান

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

আমি Intel 8085 assembly শিখছি (8080, Z80 বা 8086 নয়)। Hex লিখি Intel ধরনে, যেমন 2050H. ১. একটি program লিখে দাও: 2050H-এ item-এর সংখ্যা n (১ থেকে ২০), তারপর n টি ১৬ বিটের দাম পয়সায় (ছোট byte আগে)। মোট দাম 2060H-এ ছোট byte আগে, আর মোট FFFFH ছাড়ালে 2062H-এ 01. ২. প্রতিটি লাইনে মন্তব্য দাও, আর প্রতিটি instruction কোন flag বদলায় তা বলো। ৩. Intel 8085-এর টেবিল থেকে প্রতিটি instruction-এর T-state দাও, আর মোট T-state n-এর সূত্র হিসেবে লেখো। ৪. শুধু 8085-এর নথিভুক্ত instruction ব্যবহার করো; কোনো কিছু নিশ্চিত না হলে অনুমান কোরো না, বলো।

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

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

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

প্র ০১8085-এ গুণ আর ভাগের instruction কেন নেই, আর পরের প্রজন্মের CPU আর microcontroller এই অভাব কীভাবে মেটাল?

১৯৭৬ সালের 8085 তৈরি হয়েছিল 8080-এর instruction set প্রায় অপরিবর্তিত রেখে, আর 8080 (১৯৭৪) এসেছিল এমন এক সময়ে, যখন একটি chip-এ কয়েক হাজার transistor বসানোই বড় অর্জন। একটি hardware multiplier, এমনকি ধাপে ধাপে কাজ করা ৮ বিটের হলেও, বাড়তি register, গণক আর নিয়ন্ত্রণের যুক্তি চায়। নকশাকারীরা সেই জায়গা দিয়েছেন সাধারণ কাজে: register, ১৬ বিটের DAD, আর পুরোনো software চালানোর সামঞ্জস্য। গুণ-ভাগ কম দরকারি ধরা হয়েছিল, কারণ সেই যুগের নিয়ন্ত্রণ যন্ত্র, টার্মিনাল আর ক্যালকুলেটরের বেশিরভাগ কাজ ছিল যোগ, তুলনা, data সরানো আর I/O.

ফল হলো software-এ গুণ-ভাগ, ঠিক এই পর্বের মতো। Programmer দুটি পথের মধ্যে বেছে নিতেন: ছোট গুণকের জন্য বারবার যোগ (69 + 24b T), আর সাধারণ ক্ষেত্রে shift-add (৩৮৩ থেকে ৪৩২ T). ধ্রুবক দিয়ে গুণ আরও সস্তা: × 10 = (× 8) + (× 2), কয়েকটি DAD H আর একটি DAD D. Compiler আজও এই কৌশল ব্যবহার করে, যার নাম strength reduction.

১৯৭৮ সালের 8086 MUL, IMUL, DIV আর IDIV আনল, কিন্তু ভেতরে microcode দিয়ে, তাই সেগুলো অন্য instruction-এর তুলনায় অনেক ধীর ছিল। পরে x86 পরিবারে আলাদা দ্রুত multiplier এল। Microcontroller-এর জগতে ছবিটি মিশ্র। AVR-এর ATmega328P-তে ৮ বিটের hardware গুণ আছে, ভাগ নেই। ARM Cortex-M3 আর M4-এ ৩২ বিটের গুণ আর hardware ভাগ দুটোই আছে, কিন্তু সবচেয়ে ছোট Cortex-M0 আর M0+-এ ভাগের instruction নেই; সেখানে C-তে a / b লিখলে compiler একটি runtime library function ডাকে, যা বিয়োগ আর shift-এর loop. অর্থাৎ ১৯৭৬ সালের সমস্যাটি আজও সবচেয়ে কম খরচের chip-এ জীবিত।

এমবেডেড firmware-এর জন্য শিক্ষাটি ব্যবহারিক। বাজারঘরের scale-এর দাম হিসাবে (net_g × 6550 + 500) / 1000 একটি ভাগ আছে; Cortex-M0-এর মতো chip-এ সেটি একটি function call আর কয়েক ডজন cycle. তাই firmware লেখকেরা প্রায়ই ভাগের বদলে ২-এর ঘাতে ভাগ (shift) বা আগে থেকে হিসাব করা গুণক ব্যবহার করেন; পর্ব ৪০ (fixed-point গণিত) এই কৌশল দেখাবে।

মূল উপলব্ধি: কোন কাজ hardware-এ আর কোনটি software-এ, তা transistor-এর বাজেট ঠিক করে; 8085-এর হাতে লেখা গুণ-ভাগ আজও ছোট microcontroller-এর library-তে বেঁচে আছে।

প্র ০২Binary-তে হিসাব দ্রুত আর memory-ও কম লাগে। তবু BCD আর DAA-র মতো instruction কেন রাখা হলো, আর আজ কোথায় BCD টিকে আছে?

BCD-র সবচেয়ে বড় সুবিধা মানুষের সঙ্গে যোগাযোগে। ১৯৭০-এর দশকের ক্যালকুলেটর, ক্যাশ রেজিস্টার আর মাপার যন্ত্রে input আসত keypad থেকে দশমিক অঙ্কে, আর output যেত seven-segment display-এ দশমিক অঙ্কে। Binary-তে হিসাব করলে প্রতিবার দেখানোর আগে binary থেকে দশমিকে রূপান্তর লাগে, যা 8085-এ গুণ-ভাগ ছাড়া একটি লম্বা loop. BCD-তে প্রতিটি nibble সরাসরি একটি অঙ্ক: 23H-এর ওপরের nibble 2 আর নিচের 3 সোজা display-এ যায়। DAA একটিমাত্র ৪ T-এর instruction-এ যোগের পরে সংশোধন করে, তাই BCD-তে যোগ প্রায় binary যোগের মতোই সস্তা।

দ্বিতীয় সুবিধা দশমিক নির্ভুলতা। টাকা-পয়সার হিসাবে ০.১ বা ০.০১ binary ভগ্নাংশে ঠিকঠাক প্রকাশ করা যায় না, কিন্তু BCD-তে প্রতিটি দশমিক অঙ্ক হুবহু থাকে। ব্যাংকিং আর হিসাবের পুরোনো সিস্টেমে দশমিক গণিতের এই কারণেই এত গুরুত্ব ছিল। তবে আধুনিক firmware প্রায়ই অন্য পথ নেয়: সবকিছু সবচেয়ে ছোট এককে পূর্ণসংখ্যা হিসেবে রাখা। বাজারঘরের scale ঠিক তাই করে: দাম পয়সায়, ৮১৮৮, binary-তে, আর শুধু দেখানোর সময় ৮১.৮৮ টাকায় ভাঙা।

BCD-র দাম জায়গা আর সীমায়। এক byte-এ binary-তে ২৫৬টি মান, packed BCD-তে মাত্র ১০০টি। আর 8085-এর DAA শুধু যোগের পরে ঠিক; Z80 একটি বাড়তি flag (N) রেখে বিয়োগের পরেও DAA চালাতে পারে, আর 8086-এ DAS, AAA, AAS আলাদা instruction. মজার ব্যাপার, x86-এর ৬৪ বিটের mode-এ এই BCD instruction-গুলো আর বৈধ নয়, আর ARM বা RISC-V-এর মূল instruction set-এ এগুলো কখনো ছিলই না: compiler binary-তে হিসাব করে, আর দরকার হলে রূপান্তর করে।

তবু BCD হারিয়ে যায়নি। অনেক real-time clock chip সময় আর তারিখ BCD register-এ রাখে, যাতে সরাসরি display-এ দেখানো যায়; seven-segment driver আর কিছু মিটারেও BCD দেখা যায়। পর্ব ০৫-এ দেখেছেন, এমন register পড়তে nibble আলাদা করার কৌশল লাগে। তাই DAA-র নিয়ম বোঝা শুধু পরীক্ষার জন্য নয়, এমবেডেড কাজে BCD register পড়ার জন্যও দরকারি।

মূল উপলব্ধি: BCD মানুষের দশমিক জগৎ আর যন্ত্রের binary জগতের মাঝের সেতু; display আর ঘড়ির chip-এ এটি আজও আছে, যদিও হিসাবের কাজ বেশিরভাগ binary পূর্ণসংখ্যায় সরে গেছে।

প্র ০৩এই পর্বের অনেক program-এর সময় data-র ওপর নির্ভর করে (বড় মান খোঁজা, বারবার যোগ, ভাগ)। এমবেডেড আর নিরাপত্তার দিক থেকে এর অর্থ কী?

প্রথম অর্থ real-time নিশ্চয়তায়। একটি নিয়ন্ত্রণ যন্ত্রকে প্রায়ই নির্দিষ্ট সময়ের মধ্যে উত্তর দিতে হয়; বাজারঘরের cold-storage monitor প্রতি ১ সেকেন্ডে একটি reading নেয়। তখন প্রশ্ন “গড়ে কত সময়” নয়, “সবচেয়ে খারাপ ক্ষেত্রে কত সময়”, যাকে বলে WCET (worst-case execution time). বারবার বিয়োগের ভাগে সময় 86 + 29q T: ভাজ্য ২৫৫ আর ভাজক ১ হলে ৭৪৮১ T, প্রায় 2.5 ms; একই program 5 ÷ 9-এ ৮৬ T. পার্থক্য প্রায় ৮৭ গুণ। সূত্র জানা থাকলে সবচেয়ে খারাপ data ধরে সময় হিসাব করা যায়; না জানলে পরীক্ষার সময় যন্ত্র ঠিক চলে, আর মাঠে কোনো বিরল data-য় deadline পার হয়ে যায়। WCET আর deadline-এর পুরো আলোচনা পর্ব ৫৪ (Real-time system)-এ।

দ্বিতীয় অর্থ নকশার পছন্দে। Shift-add গুণের সময় প্রায় স্থির: ৩৮৩ থেকে ৪৩২ T, সবসময় আটটি পাক। গড়ে ছোট গুণকে সে ধীর, কিন্তু তার সবচেয়ে খারাপ ক্ষেত্র অনেক ভালো (বারবার যোগের ৬১৮৯ T-এর বিপরীতে ৪৩২ T). Real-time firmware প্রায়ই এমন পদ্ধতি বেছে নেয়, যার গড় একটু খারাপ কিন্তু সময়ের সীমা সংকীর্ণ ও জানা।

তৃতীয় অর্থ নিরাপত্তায়, যাকে timing side channel বলে। Shift-add-এর সময়ও পুরোপুরি স্থির নয়: প্রতিটি 1-বিট ৭ T বাড়ায়, তাই মোট সময় দেখে গুণকের কয়টি বিট 1, তা বোঝা যায়। গোপন চাবি নিয়ে হিসাবের program-এ এই ফাঁক বিপজ্জনক: আক্রমণকারী শুধু সময় মেপে চাবির তথ্য আন্দাজ করতে পারে। তাই cryptography-র কোড “constant-time” লেখা হয়: শর্তযুক্ত লাফের বদলে mask দিয়ে হিসাব, যাতে data যাই হোক, একই instruction একই ক্রমে চলে। 8085-এ এটি করতে হলে প্রতিটি বিটে DAD D চালিয়ে বিটটি 0 হলে ফল বাতিলের মতো কৌশল লাগত। IoT device-এর নিরাপত্তার এই দিক পর্ব ৭৬-এ আসবে।

একটি ব্যবহারিক অভ্যাস তাই এই পর্ব থেকেই শুরু করা ভালো: প্রতিটি loop-এর জন্য সূত্র লিখে রাখা, আর সবচেয়ে খারাপ data (০, ১, ২৫৫, উল্টো সাজানো) দিয়ে simulator-এ চালানো।

মূল উপলব্ধি: Data-নির্ভর সময় শুধু গতির প্রশ্ন নয়; এটি real-time-এ deadline আর নিরাপত্তায় তথ্য ফাঁসের প্রশ্ন, তাই এমবেডেড program-এর সবচেয়ে খারাপ ক্ষেত্রের সময় জানতেই হয়।

প্র ০৪Bubble sort-কে সাধারণত “ধীর algorithm” বলা হয়। তবু ৮ বিটের microprocessor-এর যুগে আর আজকের ছোট firmware-এ সরল algorithm কেন প্রায়ই বেছে নেওয়া হয়?

Algorithm-এর গতি ছোট n-এ বড় বিষয় নয়, ছোট program আর সহজ যাচাই বড় বিষয়। এই পর্বের sort program মাত্র ৩২ byte, আর ৫টি মান সাজাতে ৭১১ T, ৩ MHz-এ প্রায় ২৩৭ µs. সময়ের হিসাবে bubble sort n² অনুপাতে বাড়ে, কিন্তু n = ৫ বা ১০-এ quicksort-এর মতো algorithm-এর বাড়তি কাজ (stack, recursion, pivot বাছাই) সেই সুবিধা খেয়ে ফেলে। 8085-এর যুগে ROM কয়েক কিলোবাইট, আর প্রতিটি byte-এর জন্য লড়াই; ৩২ byte-এর একটি সঠিক program একটি ৩০০ byte-এর দ্রুত program-এর চেয়ে প্রায়ই বেশি কাজের ছিল।

দ্বিতীয় কারণ নির্ভুলতা আর পরীক্ষা। Assembly-তে প্রতিটি বাড়তি লাফ আর pointer একটি সম্ভাব্য ভুল। Bubble sort-এর loop invariant সহজ: প্রতিটি pass-এর পরে শেষ দিকের মানগুলো জায়গামতো। এটি হাতে প্রমাণ করা যায়, আর এই পর্বের মতো pass ধরে trace দিয়ে মেলানো যায়। তৃতীয় কারণ memory: bubble sort in-place, কোনো বাড়তি array লাগে না, যা ছোট RAM-এর যন্ত্রে বড় সুবিধা। Merge sort-এর মতো algorithm-এ সমান মাপের বাড়তি জায়গা লাগে।

তবে সরলতার মধ্যেও উন্নতি সম্ভব, আর এই পর্বের run তা দেখায়: pass 2-এর পরেই array সাজানো, তবু আরও দুটি pass চলে ১৮২ T খরচ করে। একটি “বদল হয়েছে” flag রাখলে প্রায় সাজানো data-য় অনেক সময় বাঁচে, যা sensor reading-এর মতো ধীরে বদলানো data-য় খুব সাধারণ। আরেকটি বিকল্প insertion sort, যা ছোট বা প্রায় সাজানো array-তে সাধারণত bubble sort-এর চেয়ে কম তুলনা আর কম লেখা করে। আধুনিক firmware-এ, যেমন median filter-এ ৫ বা ৭টি reading সাজাতে, এখনো এই ধরনের সরল sort ব্যবহার হয়। আবার বড় data-য়, যেমন একটি gateway-তে হাজারো log সাজাতে, O(n log n) algorithm ছাড়া উপায় নেই। সেই তুলনা DSA কোর্সে।

একটি সূক্ষ্ম বিষয়ও আছে: এই program CMP দিয়ে unsigned তুলনা করে। Signed reading (যেমন −০.৫০ °C-এর two's complement) সাজাতে হলে ক্রম ভুল হবে, কারণ FFH unsigned-এ সবচেয়ে বড়। তখন তুলনার আগে বিট ৭ উল্টে নেওয়ার (XRI 80H) মতো কৌশল লাগে, যা পর্ব ০৯-এ দেখেছেন।

মূল উপলব্ধি: ছোট যন্ত্রে সেরা algorithm সেটিই, যা ছোট, প্রমাণযোগ্য আর data-র আকারের সঙ্গে মানানসই; Big-O বড় n-এর গল্প বলে, এমবেডেড কাজে n প্রায়ই ছোট।

প্র ০৫এই পর্বের প্রায় সব loop গণক নিচের দিকে গোনে (DCR C / JNZ). কেন? আর গণক-ভিত্তিক loop-এর কোন ভুলগুলো সবচেয়ে বিপজ্জনক?

নিচের দিকে গোনার কারণ flag. DCR C C শূন্যে পৌঁছালেই Z = 1 বসায়, তাই পরের JNZ সরাসরি সিদ্ধান্ত নেয়; কোনো তুলনা লাগে না। ওপরের দিকে গুনলে (INR C) প্রতি পাকে আরেকটি MOV A,C আর CPI n লাগত, অর্থাৎ ১১ T বেশি, আর A register-টিও আটকে যেত। এই কারণে 8085 থেকে আধুনিক compiler পর্যন্ত loop প্রায়ই শূন্যের দিকে গোনা হয়; ARM-এর SUBS আর BNE জোড়াও একই ধারণা।

প্রথম বিপজ্জনক ভুল শূন্য গণক। MVI C,00H দিয়ে শুরু করলে প্রথম DCR C C-কে FFH বানায়, Z = 0, আর loop ২৫৬ বার চলে। এই পর্বের multiply program গুণক 0 পেলে তাই করে: ২০০ × ০-এর উত্তর ০ হওয়ার কথা, কিন্তু ফল আসে C800H = ৫১২০০, ৭৭৬টি instruction আর ৬২১৩ T খরচ করে (অনুশীলন ২)। Program কোনো error দেখায় না; শুধু ভুল উত্তর দেয়। দ্বিতীয় ভুল off-by-one: “C-তে n রাখব না n − 1?” Largest program প্রথম মানটি আগেই A-তে নেয়, তাই তুলনা n − 1টি; গণক ভুল হলে শেষ মান বাদ পড়ে বা array-র পরের অচেনা byte তুলনায় ঢুকে যায়।

তৃতীয় ভুল ১৬ বিটের গণকে। DCX B কোনো flag বসায় না, তাই DCX B তারপর JNZ আগের কোনো instruction-এর Z দেখে, আর loop হয় অসীম, নয়তো একবারে থামে। সঠিক রূপ MOV A,C, ORA B, তারপর JNZ: B আর C দুটোই শূন্য হলেই Z = 1. এই রূপটি পর্ব ১২-এর ১৬ বিটের delay loop-এর হৃদয়, যেখানে T = 24N + 7 সূত্র আসবে। চতুর্থ ভুল flag মুছে ফেলা: গণক কমানো আর শর্ত দেখার মাঝে কোনো flag-বদলানো instruction (যেমন ADD) বসালে লাফ আর গণক মেনে চলে না।

এসব ভুলের প্রতিরোধ একই: precondition লিখে রাখা আর শুরুতেই পরীক্ষা করা (ORA A / JZ), প্রতিটি লাফের ঠিক আগে কোন instruction flag বসাল তা trace-এ দেখা, আর সীমার data (০, ১, ২৫৫) দিয়ে চালানো। C-তে এই ভুলগুলোর নাম প্রায় একই থাকে: unsigned গণক শূন্য থেকে কমে বিশাল সংখ্যা হওয়া এমবেডেড C-তেও খুব পরিচিত বাগ।

মূল উপলব্ধি: নিচের দিকে গোনা flag-এর বিনামূল্যের সুবিধা নেয়, কিন্তু শূন্য গণক, এক ঘরের ভুল আর flag না বসানো DCX নীরবে ভুল ফল দেয়; প্রতিটি loop-এর সীমা আলাদা করে পরীক্ষা করতে হয়।

অনুশীলন

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

  1. নকশা ও বাস্তবায়ন — জোড় সংখ্যা গোনা: 2050H-এ গণনা n, তারপর n টি byte. কয়টি জোড় সংখ্যা, তা 2060H-এ রাখার program লিখুন। 05, 32, A7, 15, C3, 7E data-য় ফল আর মোট T-state কত?
            ORG 2000H
            LXI H,2050H
            MOV C,M         ; C <- গণনা
            MVI B,00H       ; B <- জোড়ের গণনা
    NEXT:   INX H
            MOV A,M
            ANI 01H         ; বিট 0 = 0 হলে জোড় (Z = 1)
            JNZ ODD
            INR B
    ODD:    DCR C
            JNZ NEXT
            MOV A,B
            STA 2060H
            HLT

    জোড় হলো 32H (৫০) আর 7EH (১২৬), তাই ফল ২. সত্যিকারের run: 2060H: 02, Instructions: 38 T-states: 265, ২৩ byte. ANI 01H শুধু বিট ০ রাখে; সেটি 0 হলে Z = 1. এখানে A নষ্ট হয়, কিন্তু loop প্রতিবার MOV A,M দিয়ে নতুন মান আনে, তাই সমস্যা নেই। বিকল্প: RRC দিয়ে বিট ০ CY-তে এনে JC ODD; তখনও A বদলায়।

  2. ভুল খুঁজুন — শূন্য গণক: Reference-এর repeated-addition গুণ program (LDA 2050H / MOV E,A / MVI D,00H / LDA 2051H / MOV C,A / LXI H,0000H / LOOP: DAD D / DCR C / JNZ LOOP / SHLD 2052H / HLT) 2050H = C8H (২০০) আর 2051H = 00 দিয়ে চালালে কী হবে? ভুলটি কোথায়, আর কীভাবে ঠিক করবেন?

    প্রথম DCR C 00 থেকে FFH বানায়, Z = 0, তাই loop ২৫৬ বার চলে। ফল = ২০০ × ২৫৬ = ৫১২০০ = C800H. সত্যিকারের run: 2050H: C8 00 00 C8, Instructions: 776 T-states: 6213. কোনো error নেই, শুধু ভুল উত্তর। কারণ program-এর precondition (গুণক শূন্য নয়) পরীক্ষা করা হয়নি। সমাধান: LXI H,0000H-কে আগে এনে গুণক পড়ার পরে ORA A আর JZ DONE, যেখানে DONE: SHLD 2052H. ঠিক করা program-এর run: গুণক 0-এ 2050H: C8 00 00 00, ৯টি instruction, ৮২ T; গুণক 5-এ আগের মতোই E8 03, ২০০ T (বাড়তি ORA + JZ-এর ১১ T). একই ধরনের ভুল ভাগে আরও খারাপ: ভাজক 0-এ loop কখনো থামে না।

  3. আগে বলুন, তারপর চালান — overlap: 2050H থেকে 11 22 33 44 55. Reference-এর block transfer program-এ শুধু গন্তব্য বদলে LXI D,2052H করা হলো (উৎস 2050H, গণক ৫)। চলার পরে 2050H থেকে 2056H-এ কী থাকবে? সঠিক কপি পেতে কী বদলাবেন?

    উৎস আর গন্তব্য একে অপরের ওপর পড়েছে। প্রথম পাকে 11 যায় 2052H-এ, ফলে 33 মুছে যায়; তৃতীয় পাকে উৎস 2052H থেকে পড়ে সেই 11-ই. সত্যিকারের run: 2050H: 11 22 11 22 11 22 11, ২২৯ T (সময় একই, ফল ভুল)। সমাধান: গন্তব্য উৎসের পরে থাকলে শেষ থেকে কপি করা: LXI H,2054H, LXI D,2056H, আর loop-এ DCX H, DCX D. সেই program-এর run: 2050H: 11 22 11 22 33 44 55, অর্থাৎ 2052H থেকে আসল পাঁচটি byte, আবারও ২২৯ T. C-এর memmove ঠিক এই সিদ্ধান্ত নেয়।

  4. হিসাব — সূত্র থেকে সময়: (ক) Reference-এর divide program 200 ÷ 9 করলে ভাগফল, ভাগশেষ, মোট T-state আর ৩ MHz-এ সময় কত? (খ) 200 × 13 বারবার যোগে আর shift-add-এ কত T নেবে, আর কোনটি দ্রুত?

    (ক) ২০০ = ৯ × ২২ + ২, তাই q = 22 (16H), ভাগশেষ 2. T = 86 + 29 × 22 = 86 + 638 = 724. সময় = 724 × (1/3) µs ≈ 241.33 µs. সত্যিকারের run: 2050H: C8 09 16 02, Instructions: 120 T-states: 724. (খ) বারবার যোগ: 69 + 24 × 13 = 69 + 312 = 381 T. Shift-add: 13 = 0000 1101, তিনটি 1, তাই 376 + 7 × 3 = 397 T. বারবার যোগ ১৬ T আগে শেষ করে; ১৪ থেকে উল্টো হয় (b = 14-এ 405 বনাম 397). দুটি সংখ্যাই এই পর্বের lab-এ b = 1 থেকে 255 পর্যন্ত চালানো সূত্রের যাচাই থেকে।

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

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

ক্রমএকটি 8085 array program লেখার ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. Input আর output-এর memory-ঠিকানা আর আকার ঠিক করা
  2. Algorithm লেখা বা flowchart আঁকা
  3. Register ভাগ করা: pointer, গণক আর ফল
  4. Instruction লেখা আর assemble করা
  5. ছোট data-য় dry run, তারপর simulator-এর trace আর মোট T-state মেলানো

8085-এ LDA 2050H / MOV B,A / LDA 2051H / ADD B / STA 2052H / MVI A,00H / ACI 00H / STA 2053H / HLT program-এ ACI 00H-এর কাজ কী?

  • 2051H-এর byte আবার A-তে আনা
  • A-কে শূন্য করা
  • ADD-এর carry (০ বা ১) A-তে তুলে আনা
  • CY মুছে পরের যোগের জন্য প্রস্তুত করা

8085-এ LXI H,2050H / LXI D,2060H / MVI C,N / LOOP: MOV A,M / STAX D / INX H / INX D / DCR C / JNZ LOOP / HLT program N byte কপি করে। মোট T-state কত?

  • 40N + 27
  • 40N + 29
  • 36N + 29
  • 40N + 32

8085-এ A = 38H আর B = 29H. ADD B তারপর DAA চালালে A কত হবে?

  • 61H
  • C7H
  • 70H
  • 67H

8085-এ MVI C,00H দিয়ে শুরু করে LOOP: DAD D / DCR C / JNZ LOOP চালালে loop কতবার চলবে?

  • একবারও না
  • ২৫৬ বার
  • একবার
  • কখনো থামে না

8085-এ ১৬ বিটের গণক BC দিয়ে loop চালাতে DCX B-এর পরে কোনটি লেখা উচিত?

  • সরাসরি JNZ LOOP
  • CPI 00H তারপর JNZ LOOP
  • MOV A,C, ORA B, তারপর JNZ LOOP
  • JNC LOOP

8085-এ গুণক b-এর জন্য বারবার যোগের গুণ নেয় 69 + 24b T আর shift-add নেয় 376 + 7k T, যেখানে k = b-এর 1-বিটের সংখ্যা। কোন কথাটি ঠিক?

  • Shift-add সবসময় দ্রুত
  • Shift-add-এর সময় b-এর মানের সমানুপাতিক
  • বড় b-তে বারবার যোগ ভুল ফল দেয়
  • ছোট গুণকে বারবার যোগ দ্রুত, b = 14 থেকে shift-add দ্রুত

শব্দকোষ

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

মনে রাখুন

  1. একটি ছাঁচ: pointer HL, গণক C, ফল A বা একটি register pair; loop-এর শেষে DCR C / JNZ. DCR CY ছোঁয় না, DCX কোনো flag ছোঁয় না।
  2. সময়ের সূত্র: শুরু + প্রতি পাক × পাক − ৩ + শেষ; block transfer 40N + 29, গুণ 69 + 24b বা 376 + 7k, ভাগ 86 + 29q; ৩ MHz-এ ১ T = ১/৩ µs.
  3. Carry রাখা: MVI আর INX flag ছোঁয় না, তাই ACI 00H বা পরের ADC পর্যন্ত CY বাঁচে; ১৬ বিটের বেশি যোগ byte ধরে ADD তারপর ADC.
  4. DAA: নিচের nibble ৯-এর বেশি বা AC = 1 হলে +06H, ওপরেরটি ৯-এর বেশি বা CY = 1 হলে +60H; 8085-এ শুধু যোগের পরে।
  5. সীমার data: শূন্য গণক ২৫৬ পাক, শূন্য ভাজক অসীম loop, overlap-এ সামনে থেকে কপি ভুল; প্রতিটি program 0, 1, 255 দিয়ে চালান।

পরের পর্বে: পর্ব ১২ (8085-এর stack আর subroutine — CALL, RET, PUSH আর POP). এই পর্বের program-গুলোকে subroutine বানিয়ে বারবার ডাকা, stack-এ register রক্ষা করা, আর ১৬ বিটের গণক দিয়ে সঠিক মাপের delay loop.

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

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