Assembly Language Programs on strings

AIM: To write 8086 Assembly Language Program to compare two strings.

Answer:

MODEL SMALL

.STACK 100

.DATA ; Data segment starts

STR1 DB 'FINAL YEAR EEE' ; Define string1 STR1

LEN DW ($-STR1) ; Variable LEN will have length of STR1

D DB 'EQUALS' ; Variable D points to string 'EQUALS'

F DB 'UNEQUALS' ; Variable F points to string 'UNEQUALS'

.EXTRA ; Extra segment starts

STR2 DB 'FINAL YEAR EEE' ; Define string2 STR2



.CODE ; Code segment starts

START:

MOV AX,@DATA

MOV DS,AX ; Initialize Data segment

MOV AX,@EXTRA

MOV ES,AX ; Initialize Extra segment

LEA SI,STR1 ;Lode effective address of STR1 in SI

LEA DI,STR2 ;Lode effective address of STR2 in DI

MOV CX,LEN ; Take length of string STR1 in CX register

CLD ; Clear Direction Flag

REP CMPSB ; Compare two strings till CX = 0 OR ZF ≠ 1

JNE NEXT ; Jump to NEXT if no ZF i.e. ZF = 0

LEA DX,D ; Lode effective address of string D in DX

JMP DISPLAY ; Jump to DICPLAY

NEXT:

LEA DX,F ; Lode effective address of string F in DX

DISPLAY:

MOV AH,09H ; Move 09 H in AH to display the string whose

INT 21H ; Effective address is in DX. DOS interrupt INT 21H

MOV AH,4CH ; Move 43 H in AH to terminate the program using

INT 21H ; Dos interrupt

END START

AIM: To write 8086 Assembly Language Program to add two arrays of hexadecimal
numbers using String Instructions.



Answer:



MODEL SMALL

.STACK 100

.DATA ; Data segment starts

A DB 35H, 36H, 37H, 38H ; Initialize array A

B DB 45H, 46H, 47H, 48H ; Initialize array B



.EXTRA ; Extra segment starts

Z DB ? ; Variable to store result Z



.CODE ; Code segment starts

START:

MOV AX,@DATA ;Initialize data segment

MOV DS,AX

MOV AX,@EXTRA ;Initialize extra segment

MOV ES,AX

MOV BX,0000H ;Initialize BX register to zero

MOV CL,04H ;Initialize count register to no of array elements

MOV DI,OFFSET Z ;Move the offset of Z to DI

UP: MOV AL,A[BX] ;Points to the first no in 'A'

ADD AL,B[BX] ;Adds the nth number in array A with the nth number in

; Array B and stores the result in AL.

INC BX ; Increments the BX register

STOSB ; Stores the result obtained in ES:DI

DEC CL ; Decrement count register

JNZ UP ; Jump to the label up when ZF!=0

INT 03H ; Halt

END START

INPUT: TWO ARRAYS IN DATA SEGMENT

A DB 35H, 36H, 37H, 38H

B DB 45H, 46H, 47H, 48H



OUTPUT: AN ARRAY IN EXTRA SEGMENT

Z DB 7AH, 7CH, 7EH, 80H





AIM: To write 8086 Assembly Language Program to display number of character
present in a string.

Answer:

MODEL SMALL

.STACK 100

.DATA

CR EQU 0DH

LF EQU 0AH

LEN DB 04 DUP(0)

MSG1 DB 'ENTER THE STRING.INPUT=','$'

MSG2 DB CR,LF,'THE LENGTH OF THE STRING=','$'



DISP MACRO MSG ; Micro to display a string

MOV AH,09H

MOV DX,OFFSET MSG

INT 21H

ENDM



.CODE

START:

MOV AX,@DATA

MOV DS,AX

DISP MSG1

MOV CX,00H

READ: MOV AH,01H ; Take the input string at run time

INT 21H

CMP AL,CR ; Detect the end of the string

JE AHEAD

INC CX

JMP READ



AHEAD:DISP MSG2

MOV SI,OFFSET LEN

MOV AX,CX

CALL HEX2ASC

DISP LEN

INT 03H



HEX2ASC PROC NEAR ; Procedure to convert number of character in HEX to ASCII

MOV BX,0001H

MUL BX

AAM

OR AX,3030H

MOV [SI],AH

MOV [SI+1],AL

MOV AL,'$'

MOV [SI+2],AL

INT 03H

HEX2ASC ENDP

END START

INPUT: ENTER THE STRING

.INPUT = Microprocessor lab

OUTPUT: 'THE LENGTH OF THE STRING= 18

You might be also interested in:

:: Interfacing Digital-To-Analog converter to 8086 using 8255

:: MASM 611 SOFTWARE

Assembly Language Programs on array of Hexadecimal numbers

AIM: To write 8086 Assembly Language Program to sorting n-hexadecimal number in ascending order.

Answer:

MODEL SMALL

.STACK 100

.DATA ; Data segment starts

LIST DW 53H, 25H, 02H, 19H ; Array (list) containing 4 elements is initialized.

COUNT EQU 04 ; Count is initialized to 4

.CODE ; Code segment starts

START:

MOV AX,@DATA ;Initialize the data segment

MOV DS,AX

MOV DX,COUNT-1 ;Move 03(count-1) to DX register

LOOP0: MOV CX,DX ;Move the contents of DX to CX register

MOV SI,OFFSET LIST ;Move the pointer variable of array(list) to SI

LOOP1: MOV AX,[SI] ;Move the contents of array pointed by SI to AX register

CMP AX,[SI+2] ;Compare the contents of array pointed by SI and SI+2

JL PR1 ; Transfers the control to PR1 if OF & SF are SET i.e. if 1st no<2nd style="font-size:130%;">

AIM: To write 8086 Assembly Language Program to sorting n-hexadecimal number in descending order.

Answer:

MODEL SMALL

.STACK 100

.DATA ; Data segment starts

LIST DW 53H, 25H, 02H, 19H ; Array (list) containing 4 elements is initialized.

COUNT EQU 04 ; Count is initialized to 4

.CODE ; Code segment starts

START:

MOV AX,@DATA ;Initialize the data segment

MOV DS,AX

MOV DX,COUNT-1 ;Move 03(count-1) to DX register

LOOP0: MOV CX,DX ;Move the contents of DX to CX register

MOV SI,OFFSET LIST ;Move the pointer variable of array(list) to SI

LOOP1: MOV AX,[SI] ;Move the contents of array pointed by SI to AX register

CMP AX,[SI+2] ;Compare the contents of array pointed by SI and SI+2

JG PR1 ; Transfers the control to pr1 if OF & SF

; are RESET i.e. if 1st no>2nd no.

XCHG [SI+2],AX ;Exchanges the contents of AX with [SI+2]

XCHG [SI],AX ;Exchanges the contents of AX with [SI]

PR1: ADD SI,02 ;Increments SI by 2

LOOP LOOP1 ; Control passes to LOOP1

DEC DX ; Decrement DX register

JNZ LOOP0 ; Jump to LOOP0 if CX! = 0

INT 03H

END START

INPUT:

LIST 53H, 25H, 02H, 19H

OUTPUT:

SORTED ARRAY OF THE INPUT

53H, 25H, 19H, 02H


AIM: To write 8086 Assembly Language Program to find Number of Positive & Negative hexadecimal numbers in an array.

Answer:

MODEL SMALL

.STACK 100

.DATA ; Data segment starts

LIST DW 2345H, 4567H, 8125H, 0A120H ; Initialize an array (LIST) of 16bit

COUNT EQU 04 ; Initialize count variable

.CODE ; Code segment starts

START:

XOR BX,BX ; Clear the contents of BX register

XOR DX,DX ; Clear the contents of DX register

MOV AX,@DATA ; Initialize data segment

MOV DS,AX

MOV CL,COUNT ;Move count to CL register

MOV SI,OFFSET LIST ;Offset of array is moved to SI

LOOP1: MOV AX,[SI] ;The contents of array pointed by SI are moved to AX

SHL AX,01 ;After SHL, the MSB will contain the SIGN FLAG

JC NEG1 ; Jump on no carry to NEG1

INC BX ; Increment BX register

JMP NEXT ; Jump to NEXT

NEG1: INC DX ; Increment DX register

NEXT: ADD SI,02 ;Increment SI by 2

DEC CL ; Decrement CL by 1

JNZ LOOP1 ; Jump to loop1 if ZF! = 0

INT 03H

END START

INPUT:

ARRAY OF 16BITS

LIST DW 2345H, 4567H, 8125H, 0A120H

OUTPUT:

BX register gives the no of positive numbers in the given array (LIST)

DX register gives the no of negative numbers in the given array (LIST)

AIM: To write 8086 Assembly Language Program to find Number of Even & Odd hexadecimal numbers in an array.

Answer:

MODEL SMALL

.STACK 100

.DATA ; Data segment starts

LIST DW 2345 H, 4567 H, 8125 H, 0A120 H, 6742 H ; Initialize an array (LIST) of 16bit

COUNT EQU 05 ; Initialize count variable

.CODE ; Code segment starts

START:

XOR BX,BX ;Clear the contents of BX register

XOR DX,DX ;Clear the contents of DX register

MOV AX,@DATA ;Initialize data segment

MOV DS,AX

MOV CL,COUNT ;Move count to CL register

MOV SI,OFFSET LIST ;Offset of array is moved to SI

LOOP1: MOV AX,[SI] ;The contents of array pointed by SI are moved to AX

ROR AX,01 ;After ROR, the LSB specifies if the no is even/odd

JC ODD ;Jump on no carry to ODD

INC BX ; Increment BX register

JMP NEXT ; Jump to next

ODD: INC DX ; Increment DX register

NEXT: ADD SI,02 ;Increment SI by 2

DEC CL ; Decrement CL by 1

JNZ LOOP1 ; Jump to loop1 if ZF! = 0

INT 03H

END START

INPUT: ARRAY OF 16-BITS

LIST DW 2345H, 4567H, 8125H, 0A120H

OUTPUT:

BX register gives the no of odd numbers in the given array (LIST)

DX register gives the no of odd numbers in the given array (LIST)

You might be also interested in:
:: Temperature Control system using 8086
:: Traffic light control system using 8086
:: Assembly Language Program to serve NMI

Assembly Language Programs for Multiplication and Division

this part has following programs 5 programmes



1) To write 8086 Assembly Language Program to Multiply two unsigned number.


MODEL SMALL
.STACK 100
.DATA ; Data Segment to initialize the variables
A DW 0FF87H ; First signed number A = (-79H) = FF87H (2'Compliment form)
B DW 0FF84H ; Second signed number B = (-7CH) = FF84H (2'Compliment form)
C DW ? ; Variable C to store result

.CODE
START:
MOV AX,@DATA
MOV DS,AX ; Initialize data segment
MOV SI,0000H ; Initialize SI to 0000H
MOV AX,A ;Take first number A in AX register
MOV CX,B ;Take second number B in CX register
MUL CX ; Performs unsigned Multiplication DX:AX = AX × CX
MOV C[SI],DX ; Store higher 16-bit result
MOV C[SI+2],AX ; Store lower 16-bit result
INT 03H

END START

Input:
FF87 × FF84 = FF0B 3A9C H
A = 0FF87 H (2'compliment of -79H)
B = 0FF84 H (2'compliment of -7CH)

Output:
C = FF0B 3A9C H


2) To write 8086 Assembly Language Program to multiply two signed number.


MODEL SMALL
.STACK 100
.DATA ; Data Segment to initialize the variables
A DW 0FF87H ; First signed number A = (-79H) = FF87H (2'Compliment form)
B DW 0FF84H ; Second signed number B = (-7CH) = FF84H (2'Compliment form)
C DW ? ; Variable C to store result

.CODE
START:
MOV AX,@DATA
MOV DS,AX ;Initialize data segment
MOV SI,0000H ;Initialize SI to 0000H
MOV AX,A ;Take first number A in AX register
MOV CX,B ;Take second number B in CX register
IMUL CX ; Performs signed Multiplication DX:AX = AX × CX
MOV C[SI],DX ;Store higher 16-bit result
MOV C[SI+2],AX ;Store lower 16-bit result
INT 03H

END START




Input:
-79 × -7C = 3A9C H
A = 0FF87 H (2'compliment of -79H)
B = 0FF84 H (2'compliment of -7CH)

Output:
C = 0000 3A9C H


3) To write 8086 Assembly Language Program to multiply two 32-bit unsigned numbers.


MODEL SMALL
.STACK 100
.DATA ; Data segment starts
A DW 5678H, 1234H, 5 DUP(0) ;A is 32bit number A=1234 5678
b DW 1111H, 1111H, 5 DUP(0) ;B is 32bit number B=1111 1111
C DW 4 DUP(?) ; Reserve 4 words of uninitialized data space to an offset C
.CODE
START:
MOV AX,@DATA ;Initialize DS
MOV DS,AX
MOV SI,OFFSET A ;Point to first number in A

MOV AX,WORD PTR A[SI] ;Take lower 16bits(5678) of A into AX
MUL WORD PTR B[BX+0] ;Multiply AX with lower 16bits of B(1111) and store in AX
MOV C[DI],AX ;Move the contents of AX to C[DI]
MOV CX,DX ;Move the value of DX to CX

MOV AX,WORD PTR A[SI+2] ;Take higher 16bits(1234) of A into AX
MUL WORD PTR B[BX+0] ;Multiply AX with lower 16bits of B(1111)and store in AX
ADD CX,AX ;CX=CX+AX
MOV C[DI+2],CX ;Move the contents of CX to C[DI+2]
MOV CX,DX ;Move contents of DX to CX

MOV AX,WORD PTR A[SI] ;Take lower 16bits(5678) of A in AX
MUL WORD PTR B[BX+2] ;Multiply contents of AX with higher 16bits of B(1111)
ADD WORD PTR C[DI+2],AX ;C[DI+2]=C[DI+2]+AX
ADC CX,DX ;CX=CX+DX+CF
MOV C[DI+4],AX ;Move contents of AX to C[DI+4]

MOV AX,WORD PTR A[SI+2] ;Take higher 16bits of A(1234) into AX
MUL WORD PTR B[BX+2] ;Multiply AX with higher 16bits of B(1111) and store in AX
ADD CX,AX ;CX=CX+AX
MOV WORD PTR C[DI+4],CX ;Move contents of CX to C[DI+4]
ADC DX,0000 ;DX=DX+0000+CF
MOV C[DI+6],DX ;Move the contents of DX to C[DI+6]

INT 03H ; Halt

END START


INPUT
A = 1234 5678 H
B = 1111 1111 H

OUTPUT
C=0136 BO6E 652F B5F8 H


4) To write 8086 Assembly Language Program to Division two unsigned number.


MODEL SMALL
.STACK 100
.DATA ; Data Segment to initialize the variables
Dividend DW 1234H, 5678H ; Dividend = 1234 5678 H
Divisor DW 270FH ; Divisor = 207FH
Quotient DW ? ; Variable Quotient to store Quotient
Reminder DW ? ; Variable Reminder to store Reminder

.CODE
START:
MOV AX,@DATA
MOV DS,AX ;Initialize data segment
MOV SI,0000H ;Initialize SI to 0000H
MOV DX,Dividend[SI] ;Take higher 16-bit number which is to be divided in DX register
MOV AX,Dividend[SI+2] ;Take lower 16-bit number which is to be divided in AX register
MOV CX,Divisor ;Take divisor in CX register
DIV CX ; Performs unsigned Division DX:AX ÷CX
; AX = Quotient DX = Reminder
MOV Reminder,DX ;Store Reminder
MOV Quotient,AX ;Store Quotient
INT 03H
END START




Input:
12345678H ÷ 207FH = 7751H
Dividend = 1234 5678 H
Divisor = 207F H

Output:
Quotient = 7751 H
Reminder = 01B9 H


5) To write 8086 Assembly Language Program to Division two signed number.


MODEL SMALL
.STACK 100
.DATA ; Data Segment to initialize the variables
Dividend DW 0FFFFH, 0FF88H ; Dividend = (-78H) = FFFF FF88H (2'Compliment form)
Divisor DW 0006H ; Divisor = 0006H
Quotient DW ? ; Variable Quotient to store Quotient
Reminder DW ? ; Variable Reminder to store Reminder

.CODE
START:
MOV AX,@DATA
MOV DS,AX ;Initialize data segment
MOV SI,0000H ;Initialize SI to 0000H
MOV DX,Dividend[SI] ;Take higher 16-bit number which is to be divided in DX register
MOV AX,Dividend[SI+2] ;Take lower 16-bit number which is to be divided in AX register
MOV CX,Divisor ;Take divisor in CX register
IDIV CX ; Performs signed Division DX:AX ÷ CX
; AX = Quotient DX = Reminder
MOV Reminder,DX ;Store Reminder
MOV Quotient,AX ;Store Quotient
INT 03H

END START




Input:
-78H ÷ 06H = -14H
Dividend = FFFF FF87 H (32-bit 2'compliment of -78H)
Divisor = 0006 H

Output:
Quotient = FFEC H (2'compliment of -14H)
Reminder = 0000 H

You might be also interested in:
:: Assembly Language Programs on array of Hexadecimal numbers
:: Assembly Language Programs on strings

MASM 611 SOFTWARE

hey guys,
the software its masm611 you can download it here : http://www.phatcode.net/downloads.php?id=175

I have not tried this but here is the other link
http://www.thefreecountry.com/compilers/assemblers.shtml

you can try these programs on it.
if you find any errors please comment on that programs so the we can try to fix it .

You might be also interested in:
:: Temperature Control system using 8086
:: Traffic light control system using 8086

Assembly Language Programs for Addition and Subtraction

Program for adding and subtracting numbers on microprocessor

for more detailed way i have broken down the problem into 4 sub problems they are

a) 32-bit addition for signed and unsigned numbers
b) 32-bit subtraction for signed and unsigned numbers
c) Adding two ASCII and BCD numbers
d) Subtracting two ASCII and BCD numbers

now let me write programs to each one of them::

1)
To write 8086 Assembly Language Program to add two 32-bit signed & unsigned number.

code:

MOV AX,5000H ; Initialize DATA SEGMENT
MOV DS,AX ; to 5000H
MOV AX,[1000H] ; take lower 16-bit of NUM1 in AX
MOV BX,[2000H] ; take lower 16-bit of NUM2 in BX
ADD AX,BX ; AX = AX + BX
MOV [3000H],AX ; Store lower 16-bit result at NUM3
MOV AX,[1002H] ; take higher 16-bit of NUM1 in AX
MOV BX,[2002H] ; take higher 16-bit of NUM2 in BX
ADC AX,BX ; AX = AX + BX + CF (add with carry)
MOV [3002H],AX ; Store higher 16-bit result at NUM3
HLT ; Halt 8086

i have given these inputs
NUM1 Unsigned Signed
[5000:1000] = 78H (LSB) = 88 H (LSB)
[5000:1001] = 56H = A9 H
[5000:1002] = 34H = CB H
[5000:1003] = 12H (MSB) =ED H (MSB)

NUM2
[5000:2000] = 34H (LSB) = CC H (LSB)
[5000:2001] = 12H = ED H
[5000:2002] = 34H = CB H
[5000:2003] = 12H (MSB) = ED H (MSB)


and the output is this
NUM3
[5000:3000] = ACH (LSB) = 54 H (LSB)
[5000:3001] = 68H = 97 H
[5000:3002] = 68H = 97 H
[5000:3003] = 24H (MSB) = DB H (MSB)

2)
To write 8086 Assembly Language Program to Subtract two 32-bit signed & unsigned number

MOV AX,5000H ;Initialize DATA SEGMENT
MOV DS,AX ;to 5000H
MOV AX,[1000H] ;take lower 16-bit of NUM1 in AX
MOV BX,[2000H] ;take lower 16-bit of NUM2 in BX
SUB AX,BX ;AX = AX - BX
MOV [3000H],AX ;Store lower 16-bit result at NUM3
MOV AX,[1002H] ;take higher 16-bit of NUM1 in AX
MOV BX,[2002H] ;take higher 16-bit of NUM2 in BX
SBB AX,BX ;AX = AX - BX - CF (subtract with barrow)
MOV [3002H],AX ;Store higher 16-bit result at NUM3
HLT ; Halt 8086

Input:
NUM1 Unsigned Signed
[5000:1000] = 78H (LSB) = 88 H (LSB)
[5000:1001] = 56H = A9 H
[5000:1002] = 78H = 87 H
[5000:1003] = 56H (MSB) =A9 H (MSB)

NUM2
[5000:2000] = 34H (LSB) = CC H (LSB)
[5000:2001] = 12H = ED H
[5000:2002] = 34H = CB H
[5000:2003] = 12H (MSB) = ED H (MSB)

Output:
NUM3
[5000:3000] = 44H (LSB) = BCH (LSB)
[5000:3001] = 44H = BB H
[5000:3002] = 44H = BB H
[5000:3003] = 44H (MSB) = BB H (MSB)


3)
To write 8086 Assembly Language Program to Add two ASCII & BCD number.

;ALP to add two ASCII numbers
MOV AX,5000H ;Initialize DATA SEGMENT
MOV DS,AX ;to 5000H
MOV AX,0000H ;Clear AX register
MOV AL,[1000H] ;take first ASCII number NUM1 in AL
MOV BL,[2000H] ; take second ASCII number NUM2 in BL
ADD AL,BL ;AL = AL + BL
AAA ; ASCII Adjust After Addition
OR AX,3030H ; logical OR with contents of AX & 3030H
MOV [3000H],AX ;Store ASCII result at NUM3
HLT ; Halt 8086

;ALP to add two BCD numbers
MOV AX,5000H ;Initialize DATA SEGMENT
MOV DS,AX ;to 5000H
MOV AX,0000H ;Clear AX register
MOV AL,[1000H] ;take first BCD number NUM1 in AL
MOV BL,[2000H] ; take second BCD number NUM2 in BL
ADD AL,BL ;AL = AL + BL
DAA ; Decimal Adjust After Addition
MOV [3000H],AL ;Store BCD result at NUM3
HLT ; Halt 8086

Input:
NUM1 ASCII BCD NUM2 ASCII BCD
[5000:1000] = 39H = 45H [5000:2000] = 39H = 49H

Output:
NUM3 ASCII BCD
[5000:3000] = 38H (LSB) = 94H
[5000:3001] = 31H (MSB) = 00H


4) To write 8086 Assembly Language Program to Subtract two ASCII & BCD number.


;ALP to subtract two ASCII numbers

MOV AX,5000H ;Initialize DATA SEGMENT
MOV DS,AX ;to 5000H
MOV AX,0000H ;Clear AX register
MOV AL,[1000H] ;take first ASCII number NUM1 in AL
MOV BL,[2000H] ; take second ASCII number NUM2 in BL
SUB AL,BL ;AL = AL - BL
AAS ; ASCII Adjust After Subtraction
OR AX,3030H ; logical OR with contents of AX & 3030H
MOV [3000H],AX ;Store ASCII result at NUM3
HLT ; Halt 8086

;ALP to subtract two BCD numbers

MOV AX,5000H ;Initialize DATA SEGMENT
MOV DS,AX ;to 5000H
MOV AX,0000H ;Clear AX register
MOV AL,[1000H] ;take first BCD number NUM1 in AL
MOV BL,[2000H] ; take second BCD number NUM2 in BL
SUB AL,BL ;AL = AL - BL
DAS ; Decimal Adjust After Subtraction
MOV [3000H],AL ;Store BCD result at NUM3
HLT ; Halt 8086

Input:
NUM1 ASCII BCD NUM2 ASCII BCD
[5000:1000] = 39H = 99H [5000:2000] = 34H = 49H

Output:
NUM3 ASCII BCD
[5000:3000] = 35H (LSB) = 40H
[5000:3001] = 30H (MSB) = 00H

You might be also interested in:

Assembly program for strings
:: Assembly Language Programs for Multiplication and Division
:: Traffic light control system using 8086

List of all the experiments to be written

T are all the list of Assembly Language Programs that are to be discussed in the future blog posts.

:: Assembly Language Programs for Addition and Subtraction
:: Assembly Language Programs for Multiplication and Division
:: Assembly Language Programs on array of Hexadecimal numbers
:: Assembly Language Programs on strings
:: Assembly Language Programs to compute an expression
:: Interfacing Analog-to-Digital converter to 8086 using 8255
:: Interfacing Digital-To-Analog converter to 8086 using 8255
:: Temperature Control system using 8086
:: Traffic light control system using 8086
:: Assembly Language Program to serve NMI
:: Interfacing Stepper Motor to 8086 using 8255
:: MASM 611 SOFTWARE
:: bit reversal and sorting programs
:: Find Square Root of a hexadecimal number in assembly language
:: common intreview questions on 8086
:: Assembly Language Source Codes
:: why there are two ground pins in 8086
:: Program to display ASCII characters on the display unit
:: 8051 based project for electrical students
:: free and open source 8086 Microprocessor Emulator
:: Invoke function
:: Troubleshooting a simple 8086 microprocessor based microcomputer
:: centigrade (celsius) to fahrenheit calculation for 8086 Assembly Language
:: Data transfer instructions of 8086 microprocessor
:: 8085 Microprocessor simulator for linux
::Interfacing pic microcontroller with LCD
:: Serial Port interfacing with atmega
:: TCP/IP on PIC 18 series
:: assembly program to find out the largest number from an unordered array
:: Program to find out the number of even and odd numbers from a given series
:: assembly Program to create , write and close file
:: Operator Precedence
:: 8051 or PIC microcontroller which is better
:: Effective addresses
:: Floating Point Initializations
:: options available for int 21h instruction
:: Answers of Microprocessor(8085) & Electronics FAQ
:: The 8085 Microprocessor Architecture Microprocessors & Interfacing
:: How to add two binary numbers without carry
::How to choose a MicroController
:: How to add two Hexa decimal numbers without carry
:: Adding two hexa-decimal numbers with carry


These programs are tested on masm611.