Summary of Calculator using PIC24FJ64GA006 with Proteus Simulation
Building a floating-point calculator using a PIC24FJ64GA006 microcontroller with a 4×4 keypad input and a 20×2 (LM020L) LCD display, developed in Embedded C (MPLAB C30) and testable in Proteus VSM. The system scans keypad input, stores numeric operands, performs arithmetic (including division error handling), formats results, and shows them on the LCD, providing a learning platform for keypad scanning, LCD interfacing, and microcontroller-based arithmetic processing.
Parts used in the PIC24 Calculator with Proteus Simulation:
- PIC24FJ64GA006 Microcontroller
- 20×2 Alphanumeric LCD (LM020L)
- 4×4 Matrix Keypad
- Pull-up Resistors
- Diodes for keypad isolation
- Power supply
- Proteus VSM simulation environment
Introduction
The PIC24 Calculator Proteus Simulation project demonstrates how a microcontroller can be used to build a simple digital calculator using a keypad and LCD display. In this microcontroller project, the PIC24FJ64GA006 performs arithmetic operations based on user input from a 4×4 keypad and shows the results on an LCD screen.
Developed using the MPLAB C30 compiler and tested through Proteus simulation, the PIC24 Calculator Proteus Simulation helps students and engineers understand keypad interfacing, LCD control, and real-time arithmetic processing. It is a useful practical example for learning embedded systems, microcontroller programming, and DIY electronics design.
How the Project Works (Overview)
The calculator system uses a 4×4 matrix keypad as the input interface. When a user presses a key, the PIC24 microcontroller scans the keypad rows and columns to detect which button is pressed.
The detected key is interpreted either as a numeric digit, decimal point, or arithmetic operator (+, −, ×, ÷). The program stores the entered numbers and performs floating-point calculations using internal variables.
The result of the operation is formatted and displayed on the LM020L alphanumeric LCD display connected to the microcontroller.
The entire system runs in a continuous loop where it:
Reads keypad input
Determines whether the input is a digit or operator
Stores and evaluates numeric values
Performs arithmetic operations
Displays results on the LCD
Workflow Explanation
The project architecture can be explained through the following logical flow:
User Input → Keypad Scanner → PIC24 Microcontroller → Arithmetic Processing → LCD Display
Step-by-Step Workflow
Keypad Input
A 4×4 matrix keypad provides digits and operator inputs.
Keypad Scanning
The microcontroller scans rows and columns to detect which key is pressed.
Data Processing
Numeric input is stored as a floating-point value.
Operators trigger calculation routines.
Arithmetic Evaluation
Operations like addition, subtraction, multiplication, and division are performed.
Display Output
Results are formatted and shown on the LCD screen.
Key Features
Floating-point arithmetic calculations
4×4 matrix keypad input system
LCD output display for results
Division error handling
Decimal number support
Real-time input processing
Embedded C implementation using MPLAB C30
Fully testable in Proteus VSM simulation
Components Used
The following components are identified from the schematic and firmware:
PIC24FJ64GA006 Microcontroller
20×2 Alphanumeric LCD (LM020L)
4×4 Matrix Keypad
Pull-up Resistors
Diodes for keypad isolation
Power supply
Proteus VSM simulation environment
Explanation of Code
The firmware is written in Embedded C using MPLAB C30 and is divided into several functional modules.
1. LCD Driver Module
This module initializes and controls the LCD display. It sends commands and characters to the LCD through the microcontroller’s I/O ports.
Functions include:
lcd_init()– Initializes the LCD displaywrcmd()– Sends control commandswrdata()– Writes characters to LCDclearscreen()– Clears the display
These routines manage the LCD interface and ensure proper communication with the display hardware.
2. Keypad Scanning Module
This module scans the 4×4 matrix keypad by driving rows and reading columns. When a key press is detected, it returns the corresponding ASCII value.
Example keypad mapping:
4 5 6 *
1 2 3 –
. 0 = +
The keypad scanning logic continuously checks each row and column to determine which key is pressed.
3. Calculator Logic Module
The main calculator logic performs arithmetic operations using floating-point values.
Core variables:
lvalue– left operandrvalue– right operandlastop– last operator pressed
The program evaluates operations using a switch statement that performs addition, subtraction, multiplication, or division.
Division by zero is detected and an ERROR message is displayed on the LCD.
4. Number Formatting
The program converts floating-point results into readable characters before displaying them on the LCD.
This formatting routine ensures that numbers appear correctly within the LCD display limits.
Source Code
/******************************************************************************
************ LABCENTER ELECTRONICS ************
************ Proteus VSM Sample Design Code ************
************ MPLAB C30 'C' Calculator ************
*******************************************************************************/
#include "p24FJ64GA006.h"
#include "calc.h"
#include "stddef.h"
#include "math.h"
#include "stdlib.h"
#include "string.h"
_CONFIG1(FWDTEN_OFF);
_CONFIG2(FNOSC_FRC&POSCMOD_NONE);
Proteus Simulation
The Proteus VSM simulation demonstrates how the calculator behaves in real time.
Simulation behavior:
Press digits on the keypad.
The number appears on the LCD display.
Press an operator (+, −, ×, ÷).
Enter the second number.
Press
=to calculate the result.
The LCD instantly displays the computed value, allowing developers to verify the firmware functionality without physical hardware.
Conclusion
The PIC24 Calculator with Proteus Simulation is a practical embedded systems project that demonstrates keypad interfacing, LCD communication, and arithmetic processing using a microcontroller. It is an excellent learning example for students and engineers exploring microcontroller projects, firmware development, and Proteus-based circuit simulation.
By combining embedded C programming with Proteus VSM, this project provides a hands-on approach to understanding how digital systems interact with user input and display devices in real-world electronics applications.
- How does the calculator detect which keypad key is pressed?
The microcontroller scans keypad rows and columns by driving rows and reading columns to detect the pressed key. - Can the project handle decimal numbers?
Yes, the project supports decimal number input and floating-point calculations. - What arithmetic operations are supported?
The calculator supports addition, subtraction, multiplication, and division. - How is division by zero handled?
The program detects division by zero and displays an ERROR message on the LCD. - What compiler and language are used to develop the firmware?
The firmware is written in Embedded C using the MPLAB C30 compiler. - How are results shown to the user?
Results are formatted and displayed on the 20×2 LM020L alphanumeric LCD. - Can the design be tested without physical hardware?
Yes, the design is fully testable in the Proteus VSM simulation environment. - What modules divide the firmware functionality?
The firmware is divided into LCD driver, keypad scanning, calculator logic, and number formatting modules.
