aadit/MIT-Curricular
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

proj

Browse source
This commit is contained in:
sherlock 2025-10-29 12:33:15 +05:30
parent 92e301f4e2
commit 77490396d4
1 changed files with 210 additions and 219 deletions
Download patch file Download diff file Expand all files Collapse all files

429
ES/Project/code.c
View file

@ -1,66 +1,54 @@
#include <LPC17xx.h> #include <LPC17xx.h>
/* PORT MAPPING: /* ===================================================
* KEYPAD MATRIX (4x4): * SMART CALCULATOR - LPC176x
* Columns: P0.15 - P0.18 (Output, pulled high, scan low) * Supports DEC, BIN, OCT, and HEX input modes
* Rows: P0.19 - P0.22 (Input, pulled high internally) *, with 4x4 keypad, LCD, 7-segment, and mode button.
* * ---------------------------------------------------
* Layout: 0 1 2 3 * Decimal mode: Operators B-F active directly
* 4 5 6 7 * Hexadecimal mode: Operators B-F active with MODE button
* 8 9 A B * ===================================================
* C D E F
*
* 7-SEGMENT DISPLAY:
* Segments: P0.4 - P0.11 (a-g + dp)
* Digit Enable: P1.23 (active high)
*
* LCD (16x2):
* Data: P0.23 - P0.26 (D4-D7, 4-bit mode)
* RS: P0.27
* EN: P0.28
*
* MODE BUTTON:
* P2.12 (Input, internal pull-up)
*
* KEY FUNCTIONS:
* 0-9, A-F: Digit input (valid based on current base)
*
* OPERATOR MODE (Hold Key 0 + another key):
* Key 0 + B: Addition (+)
* Key 0 + C: Clear (C)
* Key 0 + D: Subtraction (-)
* Key 0 + E: Multiplication (*)
* Key 0 + F: Equals (=)
*
* P2.12 Button: Mode selection (cycles: DEC->BIN->OCT->HEX)
*/ */
// 7-Segment patterns // 7-Segment patterns for 0-F
const unsigned char seven_seg[16] = { const unsigned char seven_seg[16] = {
0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07, 0x3F, 0x06, 0x5B, 0x4F, 0x66, 0x6D, 0x7D, 0x07,
0x7F,0x6F,0x77,0x7C,0x39,0x5E,0x79,0x71 0x7F, 0x6F, 0x77, 0x7C, 0x39, 0x5E, 0x79, 0x71
}; };
// Keypad defines /* ---------------- Pin Mapping ----------------
* Keypad (4x4):
* Columns: P0.15–P0.18 (Output)
* Rows: P0.19–P0.22 (Input, pull-up)
*
* 7-Segment:
* Segments: P0.4–P0.11
* Digit Enable: P1.23
*
* LCD:
* Data: P0.23–P0.26
* RS: P0.27, EN: P0.28
*
* Mode Button: P2.12
* ------------------------------------------------
*/
/* ===== MACROS ===== */
#define COL_BASE 15 #define COL_BASE 15
#define ROW_BASE 19 #define ROW_BASE 19
#define COL_MASK (0x0F << COL_BASE) #define COL_MASK (0x0F << COL_BASE)
#define ROW_MASK (0x0F << ROW_BASE) #define ROW_MASK (0x0F << ROW_BASE)
// 7-Segment defines
#define SEG_SHIFT 4 #define SEG_SHIFT 4
#define DIGIT_EN (1<<23) #define DIGIT_EN (1 << 23)
// LCD defines
#define LCD_DATA_SHIFT 23 #define LCD_DATA_SHIFT 23
#define LCD_DATA_MASK (0x0F << LCD_DATA_SHIFT) #define LCD_DATA_MASK (0x0F << LCD_DATA_SHIFT)
#define LCD_RS (1<<27) #define LCD_RS (1 << 27)
#define LCD_EN (1<<28) #define LCD_EN (1 << 28)
// Mode button defines #define MODE_BUTTON (1 << 12)
#define MODE_BUTTON (1<<12)
// Calculator states
#define MODE_BIN 2 #define MODE_BIN 2
#define MODE_OCT 8 #define MODE_OCT 8
#define MODE_DEC 10 #define MODE_DEC 10
@ -71,29 +59,57 @@ const unsigned char seven_seg[16] = {
#define OP_SUB 2 #define OP_SUB 2
#define OP_MUL 3 #define OP_MUL 3
// Global variables - CHANGED to signed int /* ===== Global Variables (Predeclared) ===== */
int input_num = 0; int input_num;
int stored_num = 0; int stored_num;
int result = 0; int result;
unsigned int current_base = MODE_DEC; unsigned int current_base;
unsigned int operation = OP_NONE; unsigned int operation;
unsigned char lcd_flag = 0; unsigned char lcd_flag;
unsigned char result_displayed;
void delay(volatile unsigned int d){ unsigned int key, last_key, stable;
while(d--) __NOP(); unsigned int button_state, last_button_state, button_stable;
unsigned int shift_active;
/* ===== Function Declarations ===== */
void delay(volatile unsigned int d);
void lcd_delay(unsigned long r);
void lcd_write_nibble(unsigned char nibble, unsigned char is_data);
void lcd_cmd(unsigned char cmd);
void lcd_data(unsigned char data);
void lcd_init(void);
void lcd_print_str(const char *str);
void lcd_print_num(int num, unsigned int base);
void display_mode(void);
void display_input(void);
void display_operator_feedback(const char *op_symbol);
unsigned int scan_keypad(void);
unsigned int scan_mode_button(void);
unsigned int is_valid_digit(unsigned int key);
void change_mode(void);
void operate(unsigned int op);
void perform_operation(void);
/* ===== Utility & LCD Handling ===== */
void delay(volatile unsigned int d) {
while (d--)
__NOP();
} }
void lcd_delay(unsigned long r){ void lcd_delay(unsigned long r) {
unsigned long i; unsigned long i;
for(i=0; i<r; i++); for (i = 0; i < r; i++)
;
} }
void lcd_write_nibble(unsigned char nibble, unsigned char is_data){ void lcd_write_nibble(unsigned char nibble, unsigned char is_data) {
unsigned long temp; unsigned long temp;
temp = (nibble & 0x0F) << LCD_DATA_SHIFT; temp = (nibble & 0x0F) << LCD_DATA_SHIFT;
LPC_GPIO0->FIOPIN = (LPC_GPIO0->FIOPIN & ~LCD_DATA_MASK) | temp; LPC_GPIO0->FIOPIN =
(LPC_GPIO0->FIOPIN & ~LCD_DATA_MASK) | temp;
if(is_data) if (is_data)
LPC_GPIO0->FIOSET = LCD_RS; LPC_GPIO0->FIOSET = LCD_RS;
else else
LPC_GPIO0->FIOCLR = LCD_RS; LPC_GPIO0->FIOCLR = LCD_RS;
@ -104,17 +120,17 @@ void lcd_write_nibble(unsigned char nibble, unsigned char is_data){
lcd_delay(500000); lcd_delay(500000);
} }
void lcd_cmd(unsigned char cmd){ void lcd_cmd(unsigned char cmd) {
lcd_write_nibble(cmd >> 4, 0); lcd_write_nibble(cmd >> 4, 0);
lcd_write_nibble(cmd, 0); lcd_write_nibble(cmd, 0);
} }
void lcd_data(unsigned char data){ void lcd_data(unsigned char data) {
lcd_write_nibble(data >> 4, 1); lcd_write_nibble(data >> 4, 1);
lcd_write_nibble(data, 1); lcd_write_nibble(data, 1);
} }
void lcd_init(void){ void lcd_init(void) {
lcd_delay(5000000); lcd_delay(5000000);
lcd_write_nibble(0x03, 0); lcd_write_nibble(0x03, 0);
lcd_delay(500000); lcd_delay(500000);
@ -132,101 +148,92 @@ void lcd_init(void){
lcd_cmd(0x06); lcd_cmd(0x06);
} }
void lcd_print_str(const char* str){ void lcd_print_str(const char *str) {
while(*str){ while (*str) {
lcd_data(*str++); lcd_data(*str++);
} }
} }
// MODIFIED to handle negative numbers void lcd_print_num(int num, unsigned int base) {
void lcd_print_num(int num, unsigned int base){
char buffer[17]; char buffer[17];
int i = 0; int i = 0;
// For non-decimal bases, show as unsigned (two's complement representation) if (base != MODE_DEC) {
if(base != MODE_DEC){
unsigned int unum = (unsigned int)num; unsigned int unum = (unsigned int)num;
if(unum == 0){ if (unum == 0) {
lcd_data('0'); lcd_data('0');
return; return;
} }
while(unum > 0 && i < 16){ while (unum > 0 && i < 16) {
unsigned int digit = unum % base; unsigned int digit = unum % base;
if(digit < 10) buffer[i++] = (digit < 10) ? ('0' + digit)
buffer[i++] = '0' + digit; : ('A' + (digit - 10));
else unum /= base;
buffer[i++] = 'A' + (digit - 10);
unum = unum / base;
} }
} else { } else {
// Decimal mode: handle negative with minus sign if (num < 0) {
if(num < 0){
lcd_data('-'); lcd_data('-');
num = -num; num = -num;
} }
if (num == 0) {
if(num == 0){
lcd_data('0'); lcd_data('0');
return; return;
} }
while (num > 0 && i < 16) {
while(num > 0 && i < 16){
buffer[i++] = '0' + (num % 10); buffer[i++] = '0' + (num % 10);
num = num / 10; num /= 10;
} }
} }
while (i > 0)
while(i > 0){
lcd_data(buffer[--i]); lcd_data(buffer[--i]);
}
} }
void display_mode(void){ void display_mode(void) {
lcd_cmd(0x80); lcd_cmd(0x80);
lcd_print_str("Mode: "); lcd_print_str("Mode: ");
if(current_base == MODE_BIN) if (current_base == MODE_BIN)
lcd_print_str("BIN "); lcd_print_str("BIN ");
else if(current_base == MODE_OCT) else if (current_base == MODE_OCT)
lcd_print_str("OCT "); lcd_print_str("OCT ");
else if(current_base == MODE_DEC) else if (current_base == MODE_DEC)
lcd_print_str("DEC "); lcd_print_str("DEC ");
else else
lcd_print_str("HEX "); lcd_print_str("HEX ");
} }
void display_input(void){ void display_input(void) {
lcd_cmd(0xC0); lcd_cmd(0xC0);
lcd_print_str("Inp: "); lcd_print_str("Inp: ");
lcd_print_num(input_num, current_base); lcd_print_num(input_num, current_base);
lcd_print_str(" "); lcd_print_str(" ");
} }
void display_operator_feedback(const char* op_symbol){ void display_operator_feedback(const char *op_symbol) {
// Brief feedback on line 2
lcd_cmd(0xC0); lcd_cmd(0xC0);
lcd_print_str("Op: "); lcd_print_str("Op: ");
lcd_print_str(op_symbol); lcd_print_str(op_symbol);
lcd_print_str(" "); lcd_print_str(" ");
delay(100000); // Brief delay to show feedback delay(100000);
display_input(); // Return to showing input display_input();
} }
unsigned int scan_keypad(void){ /* ====== Keypad & Button Handling ===== */
unsigned int scan_keypad(void) {
unsigned int col, row; unsigned int col, row;
unsigned int row_bits; unsigned int row_bits;
for(col=0; col<4; col++){ for (col = 0; col < 4; col++) {
LPC_GPIO0->FIOSET = COL_MASK; LPC_GPIO0->FIOSET = COL_MASK;
delay(50); delay(50);
LPC_GPIO0->FIOCLR = (1 << (COL_BASE + col)); LPC_GPIO0->FIOCLR = (1 << (COL_BASE + col));
delay(200); delay(200);
row_bits = (LPC_GPIO0->FIOPIN & ROW_MASK) >> ROW_BASE; row_bits = (LPC_GPIO0->FIOPIN & ROW_MASK) >> ROW_BASE;
if(row_bits != 0x0F){ if (row_bits != 0x0F) {
for(row=0; row<4; row++){ for (row = 0; row < 4; row++) {
if((row_bits & (1<<row)) == 0){ if ((row_bits & (1 << row)) == 0) {
LPC_GPIO0->FIOSET = COL_MASK; LPC_GPIO0->FIOSET = COL_MASK;
return col*4 + row; return col * 4 + row;
} }
} }
} }
@ -235,186 +242,170 @@ unsigned int scan_keypad(void){
return 0xFF; return 0xFF;
} }
// Check if Key 0 is currently pressed (shift key) unsigned int scan_mode_button(void) {
unsigned int is_key0_pressed(void){
unsigned int col = 0; // Key 0 is at column 0, row 0
unsigned int row_bits;
LPC_GPIO0->FIOSET = COL_MASK;
delay(50);
LPC_GPIO0->FIOCLR = (1 << (COL_BASE + col));
delay(200);
row_bits = (LPC_GPIO0->FIOPIN & ROW_MASK) >> ROW_BASE;
LPC_GPIO0->FIOSET = COL_MASK;
// Check if row 0 is pressed (Key 0)
return ((row_bits & 0x01) == 0) ? 1 : 0;
}
unsigned int scan_mode_button(void){
// Return 1 if button is pressed (active low), 0 if not pressed
return ((LPC_GPIO2->FIOPIN & MODE_BUTTON) == 0) ? 1 : 0; return ((LPC_GPIO2->FIOPIN & MODE_BUTTON) == 0) ? 1 : 0;
} }
unsigned int is_valid_digit(unsigned int key){ unsigned int is_valid_digit(unsigned int key) {
if(key >= 16) return 0; if (key >= 16)
if(current_base == MODE_BIN && key >= 2) return 0; return 0;
if(current_base == MODE_OCT && key >= 8) return 0; if (current_base == MODE_BIN && key >= 2)
if(current_base == MODE_DEC && key >= 10) return 0; return 0;
// In HEX mode, all keys 0-15 are valid digits! if (current_base == MODE_OCT && key >= 8)
return 1; return 0;
if (current_base == MODE_DEC && key >= 10)
return 0;
return 1; // HEX accepts all 0-F
} }
void change_mode(void){ void change_mode(void) {
if(current_base == MODE_DEC) if (current_base == MODE_DEC)
current_base = MODE_BIN; current_base = MODE_BIN;
else if(current_base == MODE_BIN) else if (current_base == MODE_BIN)
current_base = MODE_OCT; current_base = MODE_OCT;
else if(current_base == MODE_OCT) else if (current_base == MODE_OCT)
current_base = MODE_HEX; current_base = MODE_HEX;
else else
current_base = MODE_DEC; current_base = MODE_DEC;
display_mode(); display_mode();
} }
int main(void){ /* ===== Operator Handling ===== */
unsigned int key, last_key = 0xFF; void operate(unsigned int op) {
unsigned int stable = 0; stored_num = input_num;
unsigned int button_state, last_button_state = 0; operation = op;
unsigned int button_stable = 0; input_num = 0;
unsigned int shift_active = 0; result_displayed = 0;
}
void perform_operation(void) {
if (operation == OP_ADD)
result = stored_num + input_num;
else if (operation == OP_SUB)
result = stored_num - input_num;
else if (operation == OP_MUL)
result = stored_num * input_num;
else
result = input_num;
lcd_cmd(0xC0);
lcd_print_str("Res: ");
lcd_print_num(result, current_base);
lcd_print_str(" ");
input_num = result;
operation = OP_NONE;
result_displayed = 1;
}
/* ===== MAIN ===== */
int main(void) {
// Init globals
input_num = stored_num = result = 0;
current_base = MODE_DEC;
operation = OP_NONE;
lcd_flag = 0;
result_displayed = 0;
key = last_key = 0xFF;
stable = button_stable = 0;
button_state = last_button_state = 0;
// Configure pins
LPC_PINCON->PINSEL0 = 0; LPC_PINCON->PINSEL0 = 0;
LPC_PINCON->PINSEL1 = 0; LPC_PINCON->PINSEL1 = 0;
LPC_PINCON->PINSEL3 = 0; LPC_PINCON->PINSEL3 = 0;
LPC_PINCON->PINSEL4 = 0; // Configure P2.12 LPC_PINCON->PINSEL4 = 0;
// Keypad: Columns output, Rows input
LPC_GPIO0->FIODIR |= COL_MASK; LPC_GPIO0->FIODIR |= COL_MASK;
LPC_GPIO0->FIODIR &= ~ROW_MASK; LPC_GPIO0->FIODIR &= ~ROW_MASK;
LPC_GPIO0->FIOSET = COL_MASK; LPC_GPIO0->FIOSET = COL_MASK;
// Mode button: Input with internal pull-up LPC_GPIO2->FIODIR &= ~MODE_BUTTON;
LPC_GPIO2->FIODIR &= ~MODE_BUTTON; // Set as input
// 7-Segment
LPC_GPIO0->FIODIR |= (0xFF << SEG_SHIFT); LPC_GPIO0->FIODIR |= (0xFF << SEG_SHIFT);
LPC_GPIO1->FIODIR |= DIGIT_EN; LPC_GPIO1->FIODIR |= DIGIT_EN;
// LCD
LPC_GPIO0->FIODIR |= LCD_DATA_MASK | LCD_RS | LCD_EN; LPC_GPIO0->FIODIR |= LCD_DATA_MASK | LCD_RS | LCD_EN;
lcd_init(); lcd_init();
display_mode(); display_mode();
display_input(); display_input();
for(;;){ for (;;) {
// Check if shift key (Key 0) is being held
shift_active = is_key0_pressed();
// Scan for other keys
key = scan_keypad(); key = scan_keypad();
button_state = scan_mode_button(); button_state = scan_mode_button();
// Debounce keypad if (key == last_key) {
if(key == last_key){ if (stable < 5)
if(stable < 5) stable++; stable++;
} else { } else {
last_key = key; last_key = key;
stable = 0; stable = 0;
} }
// Debounce mode button if (button_state == last_button_state) {
if(button_state == last_button_state){ if (button_stable < 5)
if(button_stable < 5) button_stable++; button_stable++;
} else { } else {
last_button_state = button_state; last_button_state = button_state;
button_stable = 0; button_stable = 0;
} }
// Handle mode button press if (button_stable == 3 && button_state == 1) {
if(button_stable == 3 && button_state == 1){
change_mode(); change_mode();
button_stable = 5; // Prevent multiple triggers button_stable = 5;
} }
// Handle keypad input if (stable == 3 && key != 0xFF) {
if(stable == 3 && key != 0xFF){ /* =========================
// Key pressed and stable * DECIMAL MODE: Operator works directly
* HEX MODE: Operator works with MODE_BUTTON held
// If Key 0 is also pressed, we're in operator mode * ========================= */
if(shift_active && key != 0){ if ((current_base == MODE_DEC) ||
// OPERATOR MODE (Key 0 + another key) (current_base == MODE_HEX && button_state == 1)) {
if (key == 11) { // B = +
if(key == 11){ // Key 0 + B = Addition operate(OP_ADD);
stored_num = input_num;
operation = OP_ADD;
input_num = 0;
display_operator_feedback("+"); display_operator_feedback("+");
} } else if (key == 12) { // C = CLR
else if(key == 12){ // Key 0 + C = Clear input_num = stored_num = result = 0;
input_num = 0;
stored_num = 0;
operation = OP_NONE; operation = OP_NONE;
result = 0; result_displayed = 0;
display_operator_feedback("CLR"); display_operator_feedback("CLR");
} } else if (key == 13) { // D = -
else if(key == 13){ // Key 0 + D = Subtraction operate(OP_SUB);
stored_num = input_num;
operation = OP_SUB;
input_num = 0;
display_operator_feedback("-"); display_operator_feedback("-");
} } else if (key == 14) { // E = *
else if(key == 14){ // Key 0 + E = Multiplication operate(OP_MUL);
stored_num = input_num;
operation = OP_MUL;
input_num = 0;
display_operator_feedback("*"); display_operator_feedback("*");
} } else if (key == 15) { // F = =
else if(key == 15){ // Key 0 + F = Equals perform_operation();
if(operation == OP_ADD) } else if (is_valid_digit(key)) {
result = stored_num + input_num; result_displayed = 0;
else if(operation == OP_SUB) input_num = input_num * current_base + key;
result = stored_num - input_num; display_input();
else if(operation == OP_MUL) }
result = stored_num * input_num; } else {
else if (is_valid_digit(key)) {
result = input_num; result_displayed = 0;
lcd_cmd(0xC0);
lcd_print_str("Res: ");
lcd_print_num(result, current_base);
lcd_print_str(" ");
input_num = result;
operation = OP_NONE;
}
}
else {
// NORMAL MODE - Digit input
if(is_valid_digit(key)){
input_num = input_num * current_base + key; input_num = input_num * current_base + key;
// Handle overflow with wrap-around for signed int
if(input_num > 32767) input_num = input_num % 32768;
if(input_num < -32768) input_num = -32768;
display_input(); display_input();
} }
} }
stable = 5; // Prevent repeated triggers stable = 5;
} }
// Display result on 7-segment (last digit only) // ===== STATE DISPLAY on 7-Segment =====
// MODIFIED: Use decimal point to indicate negative numbers unsigned int seg_pattern;
int display_value = (input_num < 0) ? -input_num : input_num;
unsigned int display_digit = display_value % 16;
unsigned int seg_pattern = seven_seg[display_digit];
// Turn on decimal point if number is negative if (operation == OP_NONE && result_displayed == 0)
if(input_num < 0){ seg_pattern = 0x06; // '1'
seg_pattern |= 0x80; // Bit 7 is the decimal point else if (operation != OP_NONE)
} seg_pattern = 0x5B | 0x80; // '2' + DP
else if (result_displayed == 1)
seg_pattern = 0x4F | 0x80; // '3' + DP
else
seg_pattern = 0x3F; // '0'
LPC_GPIO0->FIOCLR = (0xFF << SEG_SHIFT); LPC_GPIO0->FIOCLR = (0xFF << SEG_SHIFT);
LPC_GPIO0->FIOSET = (seg_pattern << SEG_SHIFT); LPC_GPIO0->FIOSET = (seg_pattern << SEG_SHIFT);