STUDENT GRADING 8086 MICROPROCESSOR

21CSS201T– Computer Organization and Architecture

MINI PROJECT REPORT

By

K.J.TILAK REDDY(RA2211026010059)
P.BHARADWAJ(RA2211026010061)
N.UMESH KARTHIK(RA2211026010064)

Under the guidance of

Dr. C. Sherin Shibi

In partial fulfilment for the Course

of

in the Department of Computational Intelligence

FACULTY OF ENGINEERING AND TECHNOLOGY

SCHOOL OF COMPUTING

SRM INSTITUTE OF SCIENCE AND TECHNOLOGY

KATTANKULATHUR

NOVEMBER 2023
 SRM INSTITUTE OF SCIENCE AND TECHNOLOGY

(Under Section 3 of UGC Act, 1956)

BONAFIDE CERTIFICATE

Certified that this minor project report for the course 21CSS201T– Computer

Organization and Architecture entitled in "Student Grading using 8086

Microprocessor" is the bonafide work of K.J.TILAK REDDY (RA2211026010059),

P.BHARADWAJ(RA2211026010061) and N.UMESH

KARTHIK(RA2211026010064)who carried out the work under my supervision.

SIGNATURE SIGNATURE

Dr. C. Sherin Shibi Dr Annie Uthra R

COA– Course Faculty Head of the Department
Assistant Professor Professor
Department of Computational Intelligence Department of Computational Intelligence
SRM Institute of Science and Technology SRM Institute of Science and Technology
Kattankulathur Kattankulathur
 ACKNOWLEDGEMENT

We express our heartfelt thanks to our honorable Vice Chancellor Dr.

C. MUTHAMIZHCHELVAN, for being the beacon in all our endeavors.

We would like to express my warmth of gratitude to our Registrar

Dr. S. Ponnusamy, for his encouragement.
We express our profound gratitude to our Dean (College of
Engineering and Technology) Dr. T. V.Gopal, for bringing out novelty in all
executions.
We would like to express my heartfelt thanks to Chairperson, School
of Computing Dr. Revathi Venkataraman, for imparting confidence to complete
my course project
We wish to express my sincere thanks to Course Audit Professors
Dr. C. Malathy, Professor, Department of Networking and Communication and
Course Coordinator Dr. C. Sherin Shibi, Assistant Professor, Department of
Computational Intelligence for their constant encouragement and support.

We are highly thankful to our Course project Faculty Dr. C. Sherin

Shibi , Assistant Professor, Department of Computational Intelligence for her
assistance, timely suggestion and guidance throughout the duration of this course
project.
We extend my gratitude to our Head of the Department, Dr.R.Annie
Uthra, Professor, Department of Computational Intelligence and my
Departmental colleagues for their Support.

Finally, we thank our parents and friends near and dear ones who directly and

indirectly contributed to the successful completion of our project. Above all,

I thank the almighty for showering his blessings on me to complete my

Course project.
 ABSTRACT

The dynamic landscape of education necessitates innovative

approaches to streamline assessment processes.

In response to this need, our project introduces an emu8086

assembly language program designed to automate the grading of
student marks.

Traditional grading methods often involve manual evaluation,

which is not only time-intensive but also susceptible to
inconsistencies.

Our program addresses these challenges by providing a

systematic and efficient means of assigning letter grades based on
predetermined percentage criteria.

6
 TABLE OF CONTENTS

CHAPTER CONTENTS PAGE

NO NO

1 INTRODUCTION 2

1.1 Objective 2

1.2 Introduction 3

2 SOFTWARE and HARDWARE 4

REQUIREMENT

3 CONCEPT/WORKING PRINCIPLE 5

4 APPROACH/METHODOLOGY/PROGRAM 6

5 FLOWCHART 9

6 EXPERIMENT RESULTS & ANALYSIS 10

7 CONCLUSION 11

8 REFERENCES 12

1
 1.INTRODUCTION

1.1 Objective

the program takes input for marks, compares it with predefined grade boundaries,
and then prints the corresponding letter grade. Here are some objectives and
potential improvements for the code:

Code Explanation Comments:

Add comments to explain each section of the code. This will make it more readable
for others (or even yourself in the future) who may need to understand or modify
the code.
Modularization:

Break down the code into smaller, more modular functions or procedures. This can
improve code readability and make it easier to maintain.
Error Handling:

Implement error handling to check if the input marks are within a valid range (0-
100). Provide appropriate messages if the input is invalid.
Input Validation:

Ensure that the user enters a numerical value for the marks. Implement input
validation to handle non-numeric inputs.
Dynamic Grade Boundaries:

Instead of hardcoding the grade boundaries, consider making them configurable or

even dynamic. This would allow easier adjustment of grading criteria.
User-Friendly Output:

Enhance the output messages to be more user-friendly. For example, you can
display a message like "Your grade is: A+" instead of just "A+ (Plus)".
Code Optimization:

Look for opportunities to optimize the code for better performance or reduced size.
However, be cautious not to sacrifice readability for optimization in this case.
Testing:

Develop a set of test cases to ensure that the program works correctly under various

2
scenarios. Test with different input values to cover all possible grade boundaries.
Documentation:

Provide documentation for the program, including instructions on how to use it and
any specific requirements or dependencies.
Portability:

Ensure that the code is portable and can be easily adapted to run on different
assembly environments or emulators.

1.2 Introduction

The program begins with the inclusion of the 'emu8086.inc' file, which likely
contains macros or definitions specific to the emu8086 assembler. The 'org 100h'
directive sets the origin of the program to the address 100h, which is a common
starting point for DOS programs.

The code prompts the user to input a percentage value for marks and then scans
and stores the input using the 'scan_num' subroutine. After that, a series of
conditional comparisons (using the 'cmp' instruction) are made to determine the
letter grade based on the input percentage. Depending on the comparison results,
the program jumps to specific labels corresponding to different grade ranges.

For example, if the input percentage is greater than or equal to 80, the program
jumps to the 'gradeA+' label and prints 'A+ (Plus)'. The same logic is applied to
other grade ranges such as 'gradeA', 'grdA-', 'gradeB+', and so on. The final 'stop'
label is used to terminate the program after printing the determined letter grade.

It's worth noting that the program seems to use a letter grading system commonly
used in academic contexts, ranging from 'A+' to 'F' (Fail). Additionally, the code
includes macro definitions for scanning and printing numbers, although the
actual definitions are not provided in the snippet.

Overall, this assembly program is designed to interactively determine and

display a letter grade based on user-input percentage marks.

3
 2.SOFTWARE and HARDWARE REQUIREMENT

Software Requirements:
Emu8086 Emulator:

You need to have the emu8086 emulator installed on your system. The code is
specifically written for this emulator.
The emulator allows you to run and debug x86 assembly language programs on
a Windows platform.
Text Editor:

You can use any text editor to write the assembly code. Popular choices include
Notepad, Notepad++, or any integrated development environment (IDE) that
supports assembly language.
Hardware Requirements:
Windows Operating System:

Emu8086 is designed for the Windows platform, so you need a computer running
a Windows operating system.
x86-Compatible Processor:

Since the code is written for the x86 architecture, you need a computer with an
x86-compatible processor. This includes most modern CPUs.
Adequate RAM:

Ensure that your system has enough RAM to run the emulator and execute the
assembly code.
Disk Space:

Allocate some disk space for the emu8086 emulator and the assembly code file.

4
 3.CONCEPT/WORKING PRINCIPLE

Include emu8086.inc:
This line includes a file emu8086.inc, which likely contains macro definitions
and other necessary settings for the emu8086 assembler.

Set the origin (org) to 100h:

The org 100h sets the origin address of the program to 100h.

User Input:
The code prompts the user to input a numeric value for marks percentage.
print "Input Marks % value :"
call scan_num ;
This section uses a function scan_num (presumably defined in emu8086.inc) to
read an integer input from the user and stores it in the cx register.

Comparison and Grade Assignment:

The code then compares the input value with various percentage thresholds to
determine the corresponding letter grade. It uses conditional jumps (jge for
"jump if greater than or equal") to compare the input with different thresholds.
cmp cx,80
jge gradeA+
If the value is greater than or equal to 80, it jumps to the label gradeA+ and
assigns the grade "A+ (Plus)." The code follows a similar structure for the other
grade comparisons.

Printing the Result:

After determining the letter grade based on the comparisons, the code uses the
printn function (presumably defined in emu8086.inc) to print the corresponding
letter grade message.
gradeA+:
printn 'A+ (Plus)'
jmp stop
After printing the grade, a jump (jmp stop) is used to skip the execution of the
other grade comparisons.

Stopping Execution:
The code includes a stop label with a ret instruction, which likely serves as a way
to end the program or return control to the calling code.

5
 4.APPROACH/METHODOLOGY/PROGRAM

include 'emu8086.inc'

org 100h

print "Input Marks % value :"

call scan_num ;

printn ''
printn 'Your Letter Grade:'

cmp cx,80
jge gradeA+

cmp cx,75
jge gradeA

cmp cx,70
jge grdA-

cmp cx,65
jge gradeB+

cmp cx,60
jge gradeB

cmp cx,55
jge grdB-

cmp cx,50
jge gradeC+

cmp cx,45
jge gradeC

cmp cx,40
jge gradeD

6
cmp cx,40
jl gradeF

gradeA+:
printn 'A+ (Plus)'

jmp stop

gradeA:
printn 'A (Plain)'

jmp stop

grdA-:
printn 'A- (Minus)'

jmp stop

gradeB+:
printn 'B+ (Plus)'

jmp stop

gradeB:
printn 'B (Plain)'

jmp stop

grdB-:
printn 'B- (Minus)'

jmp stop

gradeC+:
printn 'C+ (Plus)'

jmp stop

gradeC:
printn 'C (Plain)'

jmp stop

7
gradeD:
printn 'D (Plain)'

jmp stop

gradeF:
printn 'F (Fail)'

jmp stop

stop:

ret

define_scan_num

define_print_num
define_print_num_uns
end

8
5.FLOWCHART

9
6. EXPERIMENT RESULTS & ANALYSIS

10
 7.CONCLUSION

The assembly code effectively implements a simple grading system that takes a
percentage input and translates it into letter grades ranging from 'A+' to 'F'.

The logic involves a series of comparisons to determine the appropriate grade

based on the input value. The use of conditional jumps (jge and jl) allows the
program to navigate through the different grade categories.

The code structure is clear and organized, with well-defined labels for each grade
category.

It also includes a set of predefined macros for scanning numbers and printing
messages. The code concludes by printing the calculated letter grade.

In summary, the assembly program efficiently converts percentage marks into

letter grades, making it a concise and functional piece of code for educational
purposes or simple grading systems in a low-level language environment.

11
 8.REFERENCES

Intel 8086 Assembly Language Documentation:

Intel 8086 Architecture Manual.
Intel 8086 Instruction Set Manual.

emu8086 Documentation:
Check the documentation for the specific features and functions
provided by the emu8086 emulator. It usually includes information
on its directives and macros.

General Assembly Language References:

"Assembly Language for x86 Processors" by Kip R. Irvine is a good
book that covers x86 assembly language programming.
Online resources such as tutorials and manuals on x86 assembly
language.

Online Assembly Language Communities:

Websites and forums like Stack Overflow, Reddit's /r/asm, and other
assembly language communities can be helpful if you have specific
questions.

Intel Manuals:
Intel provides manuals for their processors, including detailed
information on the instruction set. You can find these on the Intel
website.

12