Fixed-point Calculator

This laboratory assignment accompanies the book, Embedded Microcomputer Systems: Real Time Interfacing,
Second edition, by Jonathan W. Valvano, published by Thomson, copyright © 2006.

• Design and build a calculator,
• Develop routines for fixed- point arithmetic .
• Valvano Section 1.5.5 on fixed-point numbers.
Starter files
• None


You are not required to follow the specific syntax described in this background section. The two examples
are included to illustrate the approximate level of complexity required of your calculator. In these examples, an
ASCII string is input from the keyboard. During this input stage, a clear or backspace key allows the operator to
correct typing mistakes. During the time the operator is entering a new command, the entire LCD display shows the
command as it is being typed. There will be a specific key or keys (e.g., = ! or <ENTER>) that terminates the string
and causes the string to be interpreted.

A literal is defined a sequence of characters that represent a specific value (e.g., 0 1.3 3.14). Operators
are characters (or sequences of characters) that cause actions to occur (e.g., + - * / = ! A). There may be delimiting
characters, like spaces , which the calculator uses to define its syntax. There are two basic approaches to building a
calculator. The algebraic approach uses a syntax based on the rules of algebra . To execute binary operations
(requiring two inputs), we would type the operator between the two inputs

1.3-2.4= (sets the temporary register to -1.10)
30*0.11= (sets the temporary register to 3.30)

Binary operators (+ - * /) can be used in a unary syntax with the first parameter implied as the temporary register.
For example,

1+2= (sets the temporary register to 3.00)
+3= (sets the temporary register to 6.00)
/8= (sets the temporary register to 0.75)

To execute a unary operation (requiring one input), we would type the operator before the input

(sets the temporary register to 0.50)

To implement a save register, two functions are needed (for example, let ! mean store and let A mean recall). The
store function copies the temporary register into the save register, and the recall function can be used in place of a
literal inside a calculation. For example

1.3+1.7= (sets the temporary register to 3.00)
! (sets the save register to 3.00)
10/A= (sets the temporary register to 3.33)

In this syntax, the = and ! keys cause the line to be executed . Algebraic calculators use parentheses and operator
precedence to create complex calculations (parentheses and precedence are not required for this lab). Algebraic
calculators do not need a delimiter, like space, to separate operands. After the operator hits the = or ! key, your
calculator executes the line and shows both the temporary register and the save register.

A second approach to implementing a calculator uses Reverse Polish Notation (RPN), like an HP
calculator. An advantage of RPN is that complex calculations can be performed without parentheses or operator
precedence rules. The storage elements for a RPN calculator form a LIFO stack. In this syntax we use the <ENTER>
key to cause a line to be executed. When a literal is executed its value is pushed on the stack. For example, typing
cause a line to be executed. When a literal is executed its value is pushed on the stack. For example, typing
1.3 2.4 <ENTER> (pushes 1.30 and 2.40 on the stack, with 2.40 on top)
To execute binary operations (requiring two input), we would type the operator after the inputs
1.3 2.4 - <ENTER> (pushes a 1.30, pushes a 2.40, pops the 1.30 2.40 and pushes a -1.10)
To execute a unary operation (requiring one input), we would type the operator after the input
0.25 <ENTER> (pushes a 0.25, pops the 0.25, then pushes a 0.50 on top of the stack)

RPN calculators will need a delimiter, like space, to separate operands. Again, two functions are needed to
implement a save register (let ! mean store and let A mean recall). The store function pops the top element off the
LIFO stack storing it into the save register, and the recall function pushes the contents of the save register onto the
LIFO stack. For example

1.3 1.7 + ! <ENTER> (sets the save register to 3.00, with no net change to stack )
10 A / <ENTER> (pushes a 3.33 onto the stack, the save register still contains 3.0)

After the operator hits the <ENTER> key, your calculator executes the line and shows the top of the LIFO stack and
the save register. Because each token in a RPN calculator always does the same thing, it will be easy to implement a
calculator that supports multiple operations in one command line. E.g.,
1 2 + 3 + 8 / <ENTER> (pushes a 0.75 on top of the stack)
The RPN interpreter simply scans the string, dividing into tokens (separated by spaces + - * / )
If the token is a literal, push its value on the stack.
If the token is a binary operator, pop two elements off stack, operate, push result on the stack.
If the token is a unary operator, pop one element off stack, operate, push result on the stack.


Write the main program that implements a five-function 16-bit signed fixed -point calculator. Your calculator
will have at least two storage variables (e.g., a temporary register and a save register or a LIFO stack and a save
register). All numbers will be stored using the fixed-point format developed back in Lab 1. The matrix keyboard
will include the numbers ‘0’-‘9’, and the letters ‘+’, ‘-’, ‘*’, ‘/’, ‘=’ ‘!’ ‘A’ ‘’ and ‘.’. (The RPN calculator will also
need a space). You will need either a clear or a backspace character to let the operator correct typing errors. You are
free to design the calculator functionality in any way you wish, but you must be able to: 1) observe the save value
and the temporary; 2) type numbers in using the matrix keyboard; 3) add, subtract, multiply, divide and square root ;
4) display the results on the HD44780 LCD display. No SCI input/output is allowed in the calculator program.
Figure 10.1 shows a possible data flow graph of the calculator.

Figure 10.1. Data flows from the keyboard to the LCD.

Figure 10.2 shows a possible call graph of the system. Dividing the system into modules allows for concurrent
development and eases the reuse of code.

Figure 10.2. A call graph showing the four modules used by the calculator.


Test the calculator software in small pieces. You should stress test the system by purposely attempting illegal or
nonsensical commands. An appropriate response to illegal inputs or improper syntax is to display an error.
Similarly, the calculator should give a descriptive error after a numerical overflow, a divide by zero, or a square root
of a negative number . Record the list of test cases and the responses of your calculator. You could manually type in
the test cases and manually record the responses. Alternatively, you could create an automated test program, like
Lab 1, that feeds input strings to your calculator and records the output strings.

Deliverables (exact components of the lab report)
A) Objectives (1/2 page maximum)
B) Hardware Design
Show any changes you made since the previous lab
C) Software Design (a hardcopy software printout is due at the time of demonstration)
Describe the algorithm you used to calculate square root
Explain any data structures used to implement the calculator
If you organized the system different than Figure 10.1 and 10.2, then draw its data flow and call graphs
D) Measurement Data
Test log showing input test cases and output responses
E) Analysis and Discussion (1 page maximum)

First, the TA will attempt to use your calculator without any verbal instructions from you at all. You will then
demonstrate any additional functions the TA couldn’t figure out. Be ready to discuss issues such as range,
resolution, precision, overflow, truncation, roundoff, and dropout.
A hardcopy printout of your software will be given to your TA, and graded for style at a later time.


1) Here is a Newton’s Method for finding square root as defined in floating-point. You can convert this algorithm
into fixed-point. Overflow and dropout should be considered when implementing fixed-point calculations. Be
careful to make sure the square root function completes, and doesn’t get caught in an infinite loop. s is the input and
t is the output, such that t will become sqrt(s)
make an initial guess, e.g., t =2.0
do this calculation a small number of times depending on the precision, and the initial guess (e.g., 8)
t = ((t*t+s)/t)/2

2) Create a half-page instruction sheet, including a key code layout. This allows you to label the keys without
permanently damaging the keyboard. A good implementation allows the TA, with just this instruction sheet, to be
able to figure out and use most features of your calculator

Prev Next