1.
Intermediate ADD (8086)
ORG 2000H ; Set start address in memory at 2000H
DATA SEGMENT
SUM DW 0000H ; Reserve 2 bytes to store the sum of two numbers
CARRY DB 00H ; Reserve 1 byte to store carry flag (overflow)
DATA ENDS
CODE SEGMENT
ASSUME CS:CODE, DS:DATA
START:
MOV AX, DATA ; Load base address of DATA segment into AX
MOV DS, AX ; Initialize DS register to point to DATA segment
MOV AX, 8888H ; Load first 16-bit number into AX
MOV BX, 9999H ; Load second 16-bit number into BX
ADD AX, BX ; Add BX to AX, result stored in AX
MOV SUM, AX ; Store sum in memory location SUM
JNC L1 ; Jump to L1 if Carry Flag = 0 (no overflow)
INC CARRY ; Increment CARRY if overflow occurred
L1:
MOV SUM, AX ; Store the sum again (final value)
; Program complete
CODE ENDS
END START
2. Arithmetic Sequence / Multiplication-Subtraction (B4AC)
ORG 2000H
DATA SEGMENT
A DB 03H ; 8-bit number A
B DB 09H ; 8-bit number B
C DB 01H ; 8-bit number C
RESULT DB 00H ; 8-bit result storage
DATA ENDS
CODE SEGMENT
ASSUME CS:CODE, DS:DATA
START:
MOV AX, DATA ; Load DATA segment base address
MOV DS, AX ; Initialize DS
MOV AL, B ; Load B into AL
MUL AL ; AL * AL (unsigned), result in AX
MOV BL, AL ; Store lower byte of product in BL
MOV AL, A ; Load A into AL
MOV CL, C ; Load C into CL
MUL CL ; Multiply AL by CL, result in AX
ADD AL, AL ; Multiply result by 2 (AL = AL*2)
ADD AL, AL ; Multiply again by 2 (AL = AL*4)
SUB BL, AL ; Subtract this from previous result
MOV RESULT, BL ; Store final result
MOV AH, 4CH ; DOS terminate program
INT 21H ; Interrupt 21H - terminate program
CODE ENDS
END START
3. Sorting a Word Array (Ascending Order)
ORG 2000H
DATA SEGMENT
ARR DW 0001H,0002H,0003H,0004H,0005H ; Array of 5 words
COUNT EQU 0005H ; Number of elements
DATA ENDS
CODE SEGMENT
ASSUME CS:CODE, DS:DATA
START:
MOV AX, DATA ; Load DATA segment base address
MOV DS, AX ; Initialize DS register
MOV CX, COUNT ; Outer loop counter = array size
L3: ; Outer loop start
MOV SI, 0 ; Source index (current element)
MOV DI, 2 ; Destination index (next element, 2 bytes ahead)
DEC CX ; Decrement outer loop counter
MOV BX, CX ; Inner loop counter = CX
L2: ; Inner loop start
MOV AX, ARR[SI] ; Load current element into AX
CMP AX, ARR[DI] ; Compare with next element
JBE L1 ; If AX <= ARR[DI], skip swap
XCHG AX, ARR[DI] ; Swap AX with next element
MOV ARR[SI], AX ; Store swapped value in current position
L1: ; Move to next pair
ADD SI, 2 ; Move source index by 2 bytes
ADD DI, 2 ; Move destination index by 2 bytes
DEC BX ; Decrement inner loop counter
JNZ L2 ; Repeat inner loop if BX != 0
MOV CX, COUNT ; Reload outer loop counter
DEC CX ; Decrement outer loop
JNZ L3 ; Repeat outer loop
HLT ; Halt program
CODE ENDS
END START
4. Addition of Byte-wise Array
ORG 2000H
DATA SEGMENT
ARR1 DB 01H,02H,03H,04H ; First array of 4 bytes
ARR2 DB 05H,06H,07H,08H ; Second array of 4 bytes
SUM DB 00H,00H,00H,00H ; Array to store sum
DATA ENDS
CODE SEGMENT
ASSUME CS:CODE, DS:DATA
START:
MOV AX, DATA ; Load DATA segment base address
MOV DS, AX ; Initialize DS
MOV CL, 04H ; Counter for 4 elements
LEA SI, ARR1 ; Load address of ARR1 into SI
LEA DI, ARR2 ; Load address of ARR2 into DI
LEA BX, SUM ; Load address of SUM array into BX
L1: ; Loop to add elements
MOV AL, [SI] ; Load element from ARR1
ADD AL, [DI] ; Add corresponding element from ARR2
MOV [BX], AL ; Store result in SUM array
INC SI ; Next element in ARR1
INC DI ; Next element in ARR2
INC BX ; Next element in SUM
DEC CL ; Decrement loop counter
JNZ L1 ; Repeat loop if not zero
HLT ; Halt program
CODE ENDS
END START
5. Searching a Word in Array
ORG 2000H
DATA SEGMENT
ARR DW 0001H,0002H,0003H,0004H,0005H ; Word array
SEARCH DW 0007H ; Word to search
COUNT EQU 0005H ; Number of elements
RESULT DW 0000H ; Store count of occurrences
DATA ENDS
CODE SEGMENT
ASSUME CS:CODE, DS:DATA
START:
MOV AX, DATA ; Load DATA segment base address
MOV DS, AX ; Initialize DS
MOV CX, COUNT ; Outer loop counter
LEA SI, ARR ; Load address of array into SI
MOV AX, SEARCH ; Load word to search
L2: ; Loop through array
CMP AX, [SI] ; Compare search word with current element
JZ L1 ; If match, jump to increment result
ADD SI, 2 ; Move to next word (2 bytes)
DEC CX ; Decrement loop counter
JNZ L2 ; Repeat loop if not zero
JMP L3 ; If not found, go to end
L1: ; Found a match
INC RESULT ; Increment result counter
JMP L3
L3:
HLT ; Halt program
CODE ENDS
END START
6. Compare Two Strings (Byte-wise)
ORG 2000H
DATA SEGMENT
STR1 DB 'ABCD' ; First string
STR2 DB 'ABCD' ; Second string
COUNT DB 04H ; Number of characters
RESULT DB 00H ; 0 = same, 1 = different
DATA ENDS
CODE SEGMENT
ASSUME CS:CODE, DS:DATA
START:
MOV AX, DATA
MOV DS, AX
MOV ES, AX
MOV SI, OFFSET STR1 ; Source index
MOV DI, OFFSET STR2 ; Destination index
MOV BL, COUNT ; Number of characters
L2: ; Compare loop
CMPSB ; Compare byte at [SI] and [DI]
JZ L1 ; If equal, jump to L1
JMP L3 ; If not equal, jump to L3
L1: ; Matching bytes
DEC BL ; Decrement counter
JNZ L2 ; Continue if not finished
MOV RESULT, 01H ; Strings matched completely
JMP L4
L3:
MOV RESULT, 00H ; Strings differ
L4:
HLT ; Halt program
CODE ENDS
END START
7. Count occurrence of a character
ORG 2000H
DATA SEGMENT
MYSTRING DB 'HELLO$', 0 ; String to search, $ marks end
TARGET DB 'L' ; Character to count
OCCCOUNT DB 00H ; Store occurrence count
DATA ENDS
CODE SEGMENT
ASSUME CS:CODE, DS:DATA
START:
MOV AX, DATA ; Load DATA segment base
MOV DS, AX ; Initialize DS
LEA SI, MYSTRING ; Load address of string into SI
MOV BL, 00H ; Initialize occurrence counter to 0
L1: ; Loop through string
MOV AL, [SI] ; Load current character
CMP AL, '$' ; Check for end of string
JE L3 ; If '$', end loop
MOV DL, TARGET ; Load target character
CMP AL, DL ; Compare current character with target
JNE L2 ; If not equal, skip increment
INC BL ; If match, increment counter
L2:
INC SI ; Move to next character
JMP L1 ; Repeat loop
L3:
MOV OCCCOUNT, BL ; Store total occurrences
HLT ; Halt program
CODE ENDS
END START
[Link] of Byte array
ORG 2000H
DATA SEGMENT
NUM DB 10H,20H,30H,40H,50H ; Array of numbers
COUNT DB 05H ; Number of elements
AVG DB 00H ; Store average
SUM DW 0000H ; Temporary sum storage
DATA ENDS
CODE SEGMENT
ASSUME CS:CODE, DS:DATA
START:
MOV AX, DATA ; Load DATA segment
MOV DS, AX ; Initialize DS
MOV CL, COUNT ; Loop counter = number of elements
MOV AL, 00H ; Initialize low byte of sum
MOV AH, 00H ; Initialize high byte of sum
LEA SI, NUM ; Load address of NUM array
L1:
ADD AL, [SI] ; Add current number to AL
JNC L2 ; Jump if no carry
INC AH ; Add carry to high byte
L2:
INC SI ; Move to next number
DEC CL ; Decrement counter
JNZ L1 ; Repeat until all elements summed
MOV SUM, AX ; Store sum in memory
MOV BL, COUNT ; Load number of elements
DIV BL ; Divide sum by COUNT, quotient in AL
MOV AVG, AL ; Store average
HLT ; Halt program
CODE ENDS
END START
[Link] comparison with DOS
ORG 2000H
DATA SEGMENT
STR1 DB "ABCD",'$' ; First string
STR2 DB "ABCD",'$' ; Second string
COUNT DB 04H ; Number of characters
RES1 DB "SAME",'$' ; Message if strings match
RES2 DB "DIFFERENT",'$' ; Message if strings differ
DATA ENDS
CODE SEGMENT
ASSUME CS:CODE, DS:DATA, ES:DATA
START:
MOV AX, DATA ; Load DATA segment
MOV DS, AX
MOV ES, AX
MOV SI, OFFSET STR1 ; Point to first string
MOV DI, OFFSET STR2 ; Point to second string
MOV BL, COUNT ; Number of characters
L2:
CMPSB ; Compare bytes at SI and DI
JZ L1 ; If equal, jump to L1
JMP L3 ; If different, jump to L3
L1:
DEC BL
JNZ L2
MOV AH, 09H ; DOS print string function
MOV DX, OFFSET RES1 ; Address of "SAME" message
INT 21H ; Print message
JMP L4
L3:
MOV AH, 09H
MOV DX, OFFSET RES2 ; Address of "DIFFERENT" message
INT 21H
L4:
MOV AH, 4CH ; Terminate program
INT 21H
CODE ENDS
END START
10. File copy
ORG 2000H
DATA SEGMENT
FN DB "[Link]",'$' ; File name
MSG DB "LION_KING" ; Message to write
BUFFER DB 05H DUP (00H),'$' ; Buffer to read file
DATA ENDS
CODE SEGMENT
ASSUME CS:CODE, DS:DATA, ES:DATA
START:
MOV AX, DATA
MOV DS, AX
MOV ES, AX
; Create file
MOV AH, 3CH ; DOS create file function
MOV CX, 00H ; File attributes = normal
MOV DX, OFFSET FN ; File name
INT 21H
MOV BX, AX ; Store file handle
; Write to file
MOV AH, 40H ; DOS write function
MOV CX, 05H ; Number of bytes to write
MOV DX, OFFSET MSG ; Address of message
INT 21H
; Close file
MOV AH, 3EH ; DOS close file function
INT 21H
; Open file for reading
MOV AH, 3DH ; DOS open file function
MOV DX, OFFSET FN
INT 21H
; Read file
MOV AH, 3FH ; DOS read file function
MOV DX, OFFSET BUFFER ; Buffer to store data
MOV CX, 05H ; Number of bytes to read
INT 21H
; Display buffer
MOV AH, 09H ; DOS print string
MOV DX, OFFSET MSG ; Print MSG again (or use BUFFER)
INT 21H
; Terminate program
MOV AH, 4CH
INT 21H
CODE ENDS
END START
7 segment
ORG 2000H
DATA SEGMENT
LIST DB 71H,79H,5EH,39H,7CH,77H,6FH,7FH,07H,7DH,6DH,66H,4FH,5BH,06H,3FH ;
0-F codes
COUNT DB 10H
DATA ENDS
CODE SEGMENT
ASSUME CS:CODE, DS:DATA
START:
MOV AX, DATA
MOV DS, AX
MOV AL, 80H
MOV DX, FFE6H
OUT DX, AL ; Initialize control port
REPEAT:
LEA SI, LIST ; Pointer for first digit
MOV CL, 10H ; Loop for 10 counts
LEA DI, LIST ; Pointer for second digit
MOV CH, 10H
L1:
MOV AL, [SI] ; Output first digit
MOV DX, FFE0H
OUT DX, AL
MOV AL, [DI] ; Output second digit
MOV DX, FFE2H
OUT DX, AL
CALL DELAY
INC DI
DEC CH
JNZ L1
INC SI
DEC CL
JNZ L1
JMP REPEAT
DELAY:
MOV AH, 0AH
L3:
MOV BX, 0410H
L2:
DEC BX
JNZ L2
DEC AH
JNZ L3
RET
CODE ENDS
END START
Analog to digital :
ORG 2000H
DATA SEGMENT
DATA ENDS
CODE SEGMENT
ASSUME CS:CODE, DS:DATA
START:
MOV AX, DATA
MOV DS, AX
MOV AL, 98H ; Control word for ADC
MOV DX, FFE6H ; Control port
OUT DX, AL
REPEAT:
MOV AL, 00H
MOV DX, FFE4H ; Port C: set SC, OE, ALE = 0
OUT DX, AL
MOV AL, 00H
MOV DX, FFE2H ; Port B: select channel 0
OUT DX, AL
MOV AL, 02H
MOV DX, FFE4H ; Assert ALE
OUT DX, AL
MOV AL, 03H
MOV DX, FFE4H ; Assert SC
OUT DX, AL
MOV AL, 01H
MOV DX, FFE4H ; Unassert ALE
OUT DX, AL
MOV AL, 00H
MOV DX, FFE4H ; Unassert SC
OUT DX, AL
CHECK:
MOV DX, FFE4H
IN AL, DX ; Read EOC
RCL AL, 01H
JNC CHECK ; Wait until conversion complete
MOV AL, 04H ; Enable OE
MOV DX, FFE4H
OUT DX, AL
MOV DX, FFE0H ; Read digital data from port A
IN AL, DX
MOV BH, 00H
MOV BL, 00H
DB 9AH,12H,0BH,00H,FFH ; Monitor bytes (dummy data)
JMP REPEAT ; Repeat conversion
CODE ENDS
END START
[Link] wave
ORG 2000H
DATA SEGMENT
DATA ENDS
CODE SEGMENT
ASSUME CS:CODE, DS:DATA
START:
MOV AX, DATA
MOV DS, AX
MOV AL, 80H
MOV DX, FFE6H
OUT DX, AL ; DAC control port
L1:
MOV AL, 0FFH
MOV DX, FFE0H
OUT DX, AL ; High voltage
CALL DELAY
MOV AL, 00H
MOV DX, FFE0H
OUT DX, AL ; Low voltage
CALL DELAY
JMP L1 ; Repeat forever
DELAY:
MOV AH, 01H
L3:
MOV BX, 0410H
L2:
DEC BX
JNZ L2
DEC AH
JNZ L3
RET
CODE ENDS
END START
[Link] wave
ORG 2000H
DATA SEGMENT
LIST DB
80H,8BH,96H,A0H,ABH,B5H,BFH,CBH,D1H,D9H,E1H,E8H,EDH,F3H,F7H,FAH,FDH,FEH,
FFH
DATA ENDS
CODE SEGMENT
ASSUME CS:CODE, DS:DATA
START:
MOV AX, DATA
MOV DS, AX
MOV AL, 80H
MOV DX, FFE6H
OUT DX, AL
L1:
MOV SI, OFFSET LIST
MOV CL, 13H
L2:
MOV AL, [SI]
MOV DX, FFE0H
OUT DX, AL
INC SI
DEC CL
JNZ L2
; Optionally reverse list for full sine
JMP L1
CODE ENDS
END START
[Link] wave
ORG 3000H
DATA SEGMENT
DATA ENDS
CODE SEGMENT
ASSUME CS:CODE, DS:DATA
START:
MOV AX, DATA
MOV DS, AX
MOV AL, 80H
MOV DX, FFE6H
OUT DX, AL ; DAC control port
MOV AL, 00H ; Start from 0
L1: ; Rising edge
MOV DX, FFE0H
OUT DX, AL
INC AL
CMP AL, 0FFH
JNZ L1
L2: ; Falling edge
MOV DX, FFE0H
OUT DX, AL
DEC AL
CMP AL, 00H
JNZ L2
JMP L1 ; Repeat for continuous triangle wave
CODE ENDS
END START
[Link] motor
ORG 2000H
DATA SEGMENT
LIST DB 01H,02H,04H,08H ; Forward sequence
LIST1 DB 08H,04H,02H,01H ; Reverse sequence
DATA ENDS
CODE SEGMENT
ASSUME CS:CODE, DS:DATA
START:
MOV AX, DATA
MOV DS, AX
MOV AL, 80H
MOV DX, FFE6H
OUT DX, AL ; Initialize control port
MOV CH, 0CH ; Loop counter for steps
; Forward rotation
L2:
MOV SI, OFFSET LIST
MOV CL, 04H
L1:
MOV AL, [SI] ; Get step value
MOV DX, FFE0H
OUT DX, AL ; Output to motor
CALL DELAY
INC SI
DEC CL
JNZ L1
DEC CH
JNZ L2
MOV AL, 01H ; Additional control signals
MOV DX, FFE0H
OUT DX, AL
MOV AL, 02H
MOV DX, FFE0H
OUT DX, AL
; Reverse rotation
L4:
MOV DI, OFFSET LIST1
MOV CL, 04H
L3:
MOV AL, [DI]
MOV DX, FFE0H
OUT DX, AL
CALL DELAY
INC DI
DEC CL
JNZ L3
DEC CH
JNZ L4
MOV AL, 08H
MOV DX, FFE0H
OUT DX, AL
MOV AL, 04H
MOV DX, FFE0H
OUT DX, AL
JMP L2 ; Repeat
DELAY:
MOV BX, 2200H
L6:
DEC BX
JNZ L6
RET
CODE ENDS
END START
Traffic light :
ORG 9000H
VALUES:
DB 80H,80H,5AH
DB 44H,44H,F0H
DB 81H,81H,FAH
; ... more sequences
ORG 8000H
START:
MOV DPTR, #E803H
MOV A, #80H
MOVX @DPTR, A ; Initialize ports
AGAIN:
MOV R0, #10H
MOV DPTR, #VALUES
L:
MOVX A, @DPTR
PUSH DPL
PUSH DPH
MOV DPTR, #E800H
MOVX @DPTR, A
POP DPH
POP DPL
INC DPTR
MOVX A, @DPTR
; Repeat for E801H, E802H
LCALL DELAY
DJNZ R0, L
SJMP AGAIN
DELAY:
MOV R1, #50H
L1:
MOV R2, #FFH
L2:
MOV R3, #FFH
L3:
DJNZ R3, L3
DJNZ R2, L2
DJNZ R1, L1
RET
CODE ENDS
END START