Objective

In this post we will see how to write assembly program to Multiply Two 8 Bit BCD Numbers. Both the numbers will be provided as input to the program which in the end will calculate product. After calculation it will be adjusted before printing it to screen.

Multiple two 8 bit BCD numbers Algorithm

Program Code

Subtract 8 bit BCD numbers

Introduction 

Binary Coded Decimal Number system uses binary numbers to represent a decimal number.

Here Each decimal digit is represented by either 4-digit or 8-digit bits.

BCD is extensively used to display the numeric values in all electronic systems containing only digital logic without microprocessors.

BCD is more powerful than the binary representations. It helps in rounding off decimal values more effectively into human readable formats. 

The Disadvantages of BDC are some operations will be more complex to implement. Also BCD consumes around 20% more space compared to binary representation.

Below is the BCD representation chart for decimal digits from 0-15

Algorithm to subtract 8-bit BCD numbers

Subtract 8 Bit BCD Numbers Program

 
.model small  
 .data                                                    
 a db 32H                              
 b db 17H  
 .code  
     mov  ax, @data      ; Initialize data section  
     mov  ds, ax                                        
     mov  al, a           ; Load number1 in al  
     mov  bl, b           ; Load number2 in bl  
     sub   al, bl          ; subtract numbers and result in al  
     das                 ; adjust result to valid BCD number  
     mov  ch, 02h        ; Count of digits to be displayed  
     mov  cl, 04h         ; Count to roll by 4 bits  
     mov  bh, al          ; Result in reg bh  
 l2:  rol    bh, cl          ; roll bl so that msb comes to lsb  
     mov  dl, bh          ; load dl with data to be displayed  
     and   dl, 0fH         ; get only lsb  
     cmp  dl, 09          ; check if digit is 0-9 or letter A-F  
     jbe   l4  
     add   dl, 07          ; if letter add 37H else only add 30H  
 l4:  add   dl, 30H  
     mov  ah, 02              ; Function 2 under INT 21H (Display character)  
     int    21H  
     dec   ch            ; Decrement Count  
     jnz   l2  
     mov  ah, 4cH        ; Terminate Program  
     int    21H  
     end  

Add 8 bit BCD numbers

 .model small  
 .data  
 a db 09H                                                 
 b db 02H  
 .code  
     mov  ax, @data  ; Initialize data section  
     mov  ds, ax  
     mov  al, a       ; Load number1 in al  
     mov  bl, b      ; Load number2 in bl  
     add   al, bl      ; add numbers and result in al  
     daa            ; adjust result to valid BCD number    
     mov  ch, 02h    ; Count of digits to be displayed  
     mov  cl, 04h    ; Count to roll by 4 bits  
     mov  bh, al     ; Result in reg bh  
   rol    bh, cl     ; roll bl so that msb comes to lsb  
     mov  dl, bh     ; load dl with data to be displayed  
     and   dl, 0fH    ; get only lsb  
     cmp  dl, 09     ; check if digit is 0-9 or letter A-F  
     jbe   l4  
     add   dl, 07     ; if letter add 37H else only add 30H  
   add   dl, 30H  
     mov  ah, 02         ; Function 2 under INT 21H (Display character)  
     int    21H  
     dec   ch        ; Decrement Count  
     jnz   l2  
     mov  ah, 4cH    ; Terminate Program  
     int    21H  
     end  

Multiply Two 8 Bit Numbers by Successive Addition Method

 

Program  to Multiply Two 8 Bit Numbers  Successive Addition Method

.model small  
 .data  
 a db 12H  
 b db 10H  
 .code  
      mov      ax, @data      ; Initialize data section  
      mov      ds, ax  
      mov      al, a          ; Load number1 in al       
      mov      bl, b          ; Load number2 in bl  
      mov      ah, 0       
      mov      dx, 0          ; intialize result  
 ad:     add      dx, ax          ; add numbers. Result in dx  
      dec      bl             ; dec number  
      cmp      bl, 0                                                            Flowchart 11  
      jnz      ad                 
      mov      ch, 04h        ; Count of digits to be displayed  
      mov      cl, 04h        ; Count to roll by 4 bits  
      mov      bx, dx         ; Result in reg bx  
 l2:     rol      bx, cl      ; roll bl so that msb comes to lsb   
      mov      dl, bl         ; load dl with data to be displayed  
      and      dl, 0fH        ; get only lsb  
      cmp      dl, 09         ; check if digit is 0-9 or letter A-F  
      jbe      l4  
      add      dl, 07         ; if letter add 37H else only add 30H  
 l4:     add      dl, 30H  
      mov      ah, 02         ; Function 2 under INT 21H (Display character)  
      int      21H  
      dec      ch             ; Decrement Count  
      jnz      l2  
      mov      ah, 4cH        ; Terminate Program  
      int      21H  
      end

Multiply Two 8 Bit Numbers in Assembly Language

Step VI    :    Stop 

 

 

.model small  
 .data                                                                   
 a db 09H  
 b db 02H  
 .code  
      mov      ax, @data           ; Initialize data section  
      mov      ds, ax  
      mov      ah, 0  
      mov      al, a               ; Load number1 in al  
      mov      bl, b               ; Load number2 in bl  
      mul      bl                  ; multiply numbers and result in ax  
      mov      ch, 04h             ; Count of digits to be displayed  
      mov      cl, 04h             ; Count to roll by 4 bits  
      mov      bx, ax              ; Result in reg bx  
 l2:     rol      bx, cl           ; roll bl so that msb comes to lsb   
      mov      dl, bl              ; load dl with data to be displayed  
      and      dl, 0fH             ; get only lsb  
      cmp      dl, 09              ; check if digit is 0-9 or letter A-F  
      jbe      l4  
      add      dl, 07              ; if letter add 37H else only add 30H  
 l4:     add      dl, 30H  
      mov      ah, 02              ; Function 2 under INT 21H (Display character)  
      int      21H  
      dec      ch                  ; Decrement Count  
      jnz      l2  
      mov      ah, 4cH             ; Terminate Program  
      int      21H  
      end