Summary of PICC18 Calculator using PIC18F452 with Proteus Simulation
This PICC18 Calculator turns a PIC18F452 into a basic four-function calculator for Proteus simulation, using a 4×4 keypad for input and a 16×2 LCD for output. It demonstrates keypad scanning, LCD interfacing, number buffering, operator chaining, floating-point operations via atof(), and division-by-zero handling with an *ERROR* message—making it a compact, extendable learning project for embedded systems.
Parts used in the PICC18 Calculator:
- PIC18F452 microcontroller
- 16×2 LCD (LM020L) in 8-bit mode (D0–D7 plus control pins)
- 4×4 Keypad (digits and operators)
- Crystal oscillator X1 (1 MHz)
- Capacitors C1, C2 (10 pF)
- Reset capacitor C3 (1 µF)
- Reset resistor R5 (10 kΩ)
- Pull resistors R1–R4 (10 kΩ for keypad lines)
- Diodes D1–D4 on keypad row lines
Introduction
This PICC18 Calculator is a compact microcontroller project that turns a PIC18F452 into a simple four-function calculator using a 4×4 keypad for input and a 16×2 LCD for output. It’s designed for Proteus simulation, so you can test the full workflow without hardware.
If you’re learning embedded systems and want a practical, hands-on build, this is a clean example of keypad scanning, LCD interfacing, and basic firmware logic. It’s also a nice “starter” project for DIY electronics where the circuit diagram and source code stay easy to follow.
How the Project Works (Overview)
The calculator continuously reads keypad presses, builds a number as a string, and shows it live on the LCD. When you press an operator (+ - * /) it stores the current number and waits for the next one. When another operator (or =) is pressed, it performs the previous operation and displays the result.
From the provided firmware:
Digits and
.are collected into a buffer (number[])Values are converted using
atof()The last operator is tracked (
lastop)The result is stored in
lvalueand shown on the LCDDivision by zero is handled with an
*ERROR*message
Block Diagram / Workflow Explanation
Input → Processing → Output flow
Keypad Read
Firmware calls
keypadread()repeatedly until a key is pressed.
Key Classification
If key is a digit or
.→ add to buffer and display the typed number.If key is an operator or
=→ evaluate the previous operation.
Operation Handling
lvalueholds the running total.rvalueholds the newly entered number.lastopstores the previous operator so consecutive operations work.
LCD Output
LCD is cleared and rewritten every time the display changes (
clearscreen()+wrdata()).
Key Features (Auto-Generated)
Real-time number entry display on the LCD as digits are pressed
Four basic operations: addition, subtraction, multiplication, division
Floating-point support (uses
FLOAT,atof(), and formatting logic)Division-by-zero protection with
*ERROR*displayOperator chaining behavior (uses
lastopto process consecutive operations)Proteus-friendly design using keypad + LCD routines for simulation workflows
Components Used
Identified from the provided schematic + code references:
PIC18F452 (PIC18 family microcontroller)
16×2 LCD (LM020L) connected in 8-bit mode (D0–D7 plus control pins)
4×4 Keypad (digits + operators)
Crystal oscillator (X1: 1 MHz) with C1, C2 = 10 pF
Reset / timing components: R5 = 10 kΩ, C3 = 1 µF
Pull resistors: R1–R4 = 10 kΩ (used on keypad lines)
Diodes D1–D4 on keypad row lines (as shown in schematic)
Applications
Learning project for keypad interfacing and LCD output
Practice build for embedded systems firmware structure (state + input buffer)
Demo project in Proteus simulation for classrooms and labs
Foundation for upgrades like:
More operators (%, √, memory keys)
Better formatting / precision rules
Clear key (C) or backspace handling
Explanation of Code (High-Level)
Main flow
main()initializes the LCD and then enters calculator evaluation:lcd_init();calc_evaluate();(runs forever)
Input handling
calc_getkey()waits untilkeypadread()returns a non-zero ASCII key.calc_testkey()returns TRUE for digits and decimal point.
Evaluation logic
Digits build a string buffer (
number[]).When an operator key appears:
Converts buffer to float (
tmp = atof(number);)Stores into
lvalueorrvaluedepending on whether an operator is pendingExecutes the previous operation (
calc_opfunctions(lastop))Updates
lastopunless key was=
Display formatting
calc_format()converts a float into a displayable string using divisors and inserts a decimal point at0.1.calc_display()clears the LCD and writes characters one-by-one usingwrdata().
Source Code
#include "calc.h"
#include "stdio.h"
#include "math.h"
#include "stdlib.h"
//Variables
static FLOAT lvalue = 0;
static FLOAT rvalue = 0;
static CHAR lastop;
VOID main (VOID)
// Initialise our variables and call the
// Assembly routine to initialise the LCD display. Proteus Simulation
In Proteus, the 4×4 keypad acts as your input device and the LM020L LCD shows the typed digits and results. On startup, the firmware initializes the LCD and displays 0. As you press keys:
Digits build a number on-screen
Operators trigger evaluation using the previously stored operator
Pressing
=completes the operation and resetslastopDivision by zero shows
*ERROR*
(FAQs)
Conclusion
The PICC18 Calculator is a solid, practical embedded systems project: keypad input, LCD output, and clean operator-based evaluation running on the PIC18F452 in Proteus simulation. It’s simple enough to understand quickly, but structured well enough to extend—making it a strong learning build for DIY electronics, firmware logic, and microcontroller interfacing.
- Why does the LCD show nothing in Proteus?
Because the display depends on routines like lcd_init(), clearscreen(), and wrdata(); if those are missing or mismatched the LCD will not update. - The keypad doesn’t respond—what should I check first?
Check that keypadread() is functioning and Proteus wiring for the keypad, since the firmware waits until keypadread() returns a non-zero value. - Can I run this on another PIC18 device?
Possibly, but port mapping (LCD and keypad lines) is schematic-specific and moving to another PIC may require pin and port changes. - Why is the display formatting custom instead of using printf?
The code uses calc_format() with divisors to control display width and decimal placement rather than using printf. - How does the project handle multiple operations in a row?
It stores the previous operator in lastop and executes calc_opfunctions(lastop) when a new operator is entered before updating lastop. - What happens if I press operators without entering numbers?
The logic resets the input buffer and uses lastop to detect consecutive operator behavior; results depend on the current lvalue and rvalue state. - Why do I get *ERROR* sometimes?
*ERROR* is displayed when a division by zero occurs (division operator with rvalue equal to zero). - Can I add a Clear (C) key?
Yes; treat a keypad character as a reset command to clear the buffer and set lvalue, rvalue, and lastop back to zero then call calc_format(0).
