471 lines
12 KiB
C
471 lines
12 KiB
C
#include <LPC17xx.h>
|
|
|
|
/* PORT MAPPING:
|
|
* KEYPAD MATRIX (4x4):
|
|
* Columns: P0.15 - P0.18 (Output, pulled high, scan low)
|
|
* Rows: P0.19 - P0.22 (Input, pulled high internally)
|
|
*
|
|
* Layout: 0 1 2 3
|
|
* 4 5 6 7
|
|
* 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 KEYS:
|
|
* DEC/BIN/OCT modes (direct press):
|
|
* Key A: Addition (+)
|
|
* Key B: Subtraction (-)
|
|
* Key C: Multiplication (*)
|
|
* Key D: Equals (=)
|
|
* Key E: Clear (C)
|
|
*
|
|
* HEX mode (hold MODE + key):
|
|
* MODE + A: Addition (+)
|
|
* MODE + B: Subtraction (-)
|
|
* MODE + C: Multiplication (*)
|
|
* MODE + D: Equals (=)
|
|
* MODE + E: Clear (C)
|
|
*
|
|
* P2.12 Button:
|
|
* Short press: Mode selection (cycles: DEC->BIN->OCT->HEX)
|
|
* Hold + key (HEX mode only): Operator input
|
|
*
|
|
* 7-SEGMENT STATE DISPLAY:
|
|
* '1' - Input mode (entering numbers)
|
|
* '2' with DP - Operation pending (waiting for 2nd number)
|
|
* '3' with DP - Result ready (showing calculation result)
|
|
* '0' - Cleared/Reset state (fallback)
|
|
*/
|
|
|
|
// 7-Segment patterns
|
|
const unsigned char seven_seg[16] = {
|
|
0x3F, 0x06, 0x5B, 0x4F, 0x66, 0x6D, 0x7D, 0x07,
|
|
0x7F, 0x6F, 0x77, 0x7C, 0x39, 0x5E, 0x79, 0x71
|
|
};
|
|
|
|
// Keypad defines
|
|
#define COL_BASE 15
|
|
#define ROW_BASE 19
|
|
#define COL_MASK (0x0F << COL_BASE)
|
|
#define ROW_MASK (0x0F << ROW_BASE)
|
|
|
|
// 7-Segment defines
|
|
#define SEG_SHIFT 4
|
|
#define DIGIT_EN (1 << 23)
|
|
|
|
// LCD defines
|
|
#define LCD_DATA_SHIFT 23
|
|
#define LCD_DATA_MASK (0x0F << LCD_DATA_SHIFT)
|
|
#define LCD_RS (1 << 27)
|
|
#define LCD_EN (1 << 28)
|
|
|
|
// Mode button defines
|
|
#define MODE_BUTTON (1 << 12)
|
|
|
|
// Calculator states
|
|
#define MODE_BIN 2
|
|
#define MODE_OCT 8
|
|
#define MODE_DEC 10
|
|
#define MODE_HEX 16
|
|
|
|
#define OP_NONE 0
|
|
#define OP_ADD 1
|
|
#define OP_SUB 2
|
|
#define OP_MUL 3
|
|
|
|
// Global variables
|
|
int input_num = 0;
|
|
int stored_num = 0;
|
|
int result = 0;
|
|
unsigned int current_base = MODE_DEC;
|
|
unsigned int operation = OP_NONE;
|
|
unsigned char result_displayed = 0;
|
|
unsigned int key = 0xFF;
|
|
unsigned int last_key = 0xFF;
|
|
unsigned int stable = 0;
|
|
unsigned int mode_held = 0;
|
|
unsigned int mode_press_counter = 0;
|
|
unsigned int key_pressed_with_mode = 0;
|
|
unsigned int mode_current = 0;
|
|
int is_operator_key = 0;
|
|
int operator_mode = 0;
|
|
unsigned int seg_pattern = 0;
|
|
|
|
void delay(volatile unsigned int d) {
|
|
while(d--)
|
|
__NOP();
|
|
}
|
|
|
|
void lcd_delay(unsigned long r) {
|
|
unsigned long i;
|
|
for(i = 0; i < r; i++);
|
|
}
|
|
|
|
void lcd_write_nibble(unsigned char nibble, unsigned char is_data) {
|
|
unsigned long temp;
|
|
temp = (nibble & 0x0F) << LCD_DATA_SHIFT;
|
|
LPC_GPIO0->FIOPIN = (LPC_GPIO0->FIOPIN & ~LCD_DATA_MASK) | temp;
|
|
|
|
if(is_data)
|
|
LPC_GPIO0->FIOSET = LCD_RS;
|
|
else
|
|
LPC_GPIO0->FIOCLR = LCD_RS;
|
|
|
|
LPC_GPIO0->FIOSET = LCD_EN;
|
|
lcd_delay(100);
|
|
LPC_GPIO0->FIOCLR = LCD_EN;
|
|
lcd_delay(500000);
|
|
}
|
|
|
|
void lcd_cmd(unsigned char cmd) {
|
|
lcd_write_nibble(cmd >> 4, 0);
|
|
lcd_write_nibble(cmd, 0);
|
|
}
|
|
|
|
void lcd_data(unsigned char data) {
|
|
lcd_write_nibble(data >> 4, 1);
|
|
lcd_write_nibble(data, 1);
|
|
}
|
|
|
|
void lcd_init(void) {
|
|
lcd_delay(5000000);
|
|
lcd_write_nibble(0x03, 0);
|
|
lcd_delay(500000);
|
|
lcd_write_nibble(0x03, 0);
|
|
lcd_delay(500000);
|
|
lcd_write_nibble(0x03, 0);
|
|
lcd_delay(500000);
|
|
lcd_write_nibble(0x02, 0);
|
|
lcd_delay(500000);
|
|
|
|
lcd_cmd(0x28);
|
|
lcd_cmd(0x0C);
|
|
lcd_cmd(0x01);
|
|
lcd_delay(500000);
|
|
lcd_cmd(0x06);
|
|
}
|
|
|
|
void lcd_print_str(const char* str) {
|
|
while(*str) {
|
|
lcd_data(*str++);
|
|
}
|
|
}
|
|
|
|
void lcd_print_num(int num, unsigned int base) {
|
|
char buffer[17];
|
|
int i = 0;
|
|
|
|
if(base != MODE_DEC) {
|
|
unsigned int unum = (unsigned int)num;
|
|
if(unum == 0) {
|
|
lcd_data('0');
|
|
return;
|
|
}
|
|
while(unum > 0 && i < 16) {
|
|
unsigned int digit = unum % base;
|
|
if(digit < 10)
|
|
buffer[i++] = '0' + digit;
|
|
else
|
|
buffer[i++] = 'A' + (digit - 10);
|
|
unum = unum / base;
|
|
}
|
|
} else {
|
|
if(num < 0) {
|
|
lcd_data('-');
|
|
num = -num;
|
|
}
|
|
|
|
if(num == 0) {
|
|
lcd_data('0');
|
|
return;
|
|
}
|
|
|
|
while(num > 0 && i < 16) {
|
|
buffer[i++] = '0' + (num % 10);
|
|
num = num / 10;
|
|
}
|
|
}
|
|
|
|
while(i > 0) {
|
|
lcd_data(buffer[--i]);
|
|
}
|
|
}
|
|
|
|
void display_mode(void) {
|
|
lcd_cmd(0x80);
|
|
lcd_print_str("Mode: ");
|
|
if(current_base == MODE_BIN)
|
|
lcd_print_str("BIN ");
|
|
else if(current_base == MODE_OCT)
|
|
lcd_print_str("OCT ");
|
|
else if(current_base == MODE_DEC)
|
|
lcd_print_str("DEC ");
|
|
else
|
|
lcd_print_str("HEX ");
|
|
}
|
|
|
|
void display_status(void) {
|
|
lcd_cmd(0xC0);
|
|
|
|
if(operation != OP_NONE) {
|
|
// Show operation pending
|
|
lcd_print_str("Op:");
|
|
if(operation == OP_ADD)
|
|
lcd_data('+');
|
|
else if(operation == OP_SUB)
|
|
lcd_data('-');
|
|
else if(operation == OP_MUL)
|
|
lcd_data('*');
|
|
|
|
lcd_print_str(" Val:");
|
|
lcd_print_num(stored_num, current_base);
|
|
lcd_print_str(" ");
|
|
} else if(result_displayed) {
|
|
// Show result
|
|
lcd_print_str("Res: ");
|
|
lcd_print_num(result, current_base);
|
|
lcd_print_str(" ");
|
|
} else {
|
|
// Show current input
|
|
lcd_print_str("Inp: ");
|
|
lcd_print_num(input_num, current_base);
|
|
lcd_print_str(" ");
|
|
}
|
|
}
|
|
|
|
unsigned int scan_keypad(void) {
|
|
unsigned int col, row;
|
|
unsigned int row_bits;
|
|
|
|
for(col = 0; col < 4; col++) {
|
|
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;
|
|
|
|
if(row_bits != 0x0F) {
|
|
for(row = 0; row < 4; row++) {
|
|
if((row_bits & (1 << row)) == 0) {
|
|
LPC_GPIO0->FIOSET = COL_MASK;
|
|
return col * 4 + row;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
LPC_GPIO0->FIOSET = COL_MASK;
|
|
return 0xFF;
|
|
}
|
|
|
|
unsigned int is_mode_button_pressed(void) {
|
|
return ((LPC_GPIO2->FIOPIN & MODE_BUTTON) == 0) ? 1 : 0;
|
|
}
|
|
|
|
unsigned int is_valid_digit(unsigned int key) {
|
|
if(key >= 16)
|
|
return 0;
|
|
if(current_base == MODE_BIN && key >= 2)
|
|
return 0;
|
|
if(current_base == MODE_OCT && key >= 8)
|
|
return 0;
|
|
if(current_base == MODE_DEC && key >= 10)
|
|
return 0;
|
|
return 1;
|
|
}
|
|
|
|
void change_mode(void) {
|
|
if(current_base == MODE_DEC)
|
|
current_base = MODE_BIN;
|
|
else if(current_base == MODE_BIN)
|
|
current_base = MODE_OCT;
|
|
else if(current_base == MODE_OCT)
|
|
current_base = MODE_HEX;
|
|
else
|
|
current_base = MODE_DEC;
|
|
|
|
input_num = 0;
|
|
stored_num = 0;
|
|
operation = OP_NONE;
|
|
result = 0;
|
|
result_displayed = 0;
|
|
|
|
display_mode();
|
|
display_status();
|
|
}
|
|
|
|
int main(void) {
|
|
// Configure pins
|
|
LPC_PINCON->PINSEL0 = 0;
|
|
LPC_PINCON->PINSEL1 = 0;
|
|
LPC_PINCON->PINSEL3 = 0;
|
|
LPC_PINCON->PINSEL4 = 0;
|
|
|
|
// Keypad: Columns output, Rows input
|
|
LPC_GPIO0->FIODIR |= COL_MASK;
|
|
LPC_GPIO0->FIODIR &= ~ROW_MASK;
|
|
LPC_GPIO0->FIOSET = COL_MASK;
|
|
|
|
// Mode button: Input with internal pull-up
|
|
LPC_GPIO2->FIODIR &= ~MODE_BUTTON;
|
|
|
|
// 7-Segment
|
|
LPC_GPIO0->FIODIR |= (0xFF << SEG_SHIFT);
|
|
LPC_GPIO1->FIODIR |= DIGIT_EN;
|
|
|
|
// LCD
|
|
LPC_GPIO0->FIODIR |= LCD_DATA_MASK | LCD_RS | LCD_EN;
|
|
|
|
lcd_init();
|
|
display_mode();
|
|
display_status();
|
|
|
|
for(;;) {
|
|
// Check if MODE button is currently pressed
|
|
mode_current = is_mode_button_pressed();
|
|
|
|
// Scan keypad
|
|
key = scan_keypad();
|
|
|
|
// Debounce keypad
|
|
if(key == last_key) {
|
|
if(stable < 5)
|
|
stable++;
|
|
} else {
|
|
last_key = key;
|
|
stable = 0;
|
|
}
|
|
|
|
// Track MODE button hold
|
|
if(mode_current) {
|
|
mode_press_counter++;
|
|
mode_held = 1;
|
|
} else {
|
|
// MODE button released
|
|
if(mode_held && !key_pressed_with_mode &&
|
|
mode_press_counter < 50) {
|
|
// Short press without key combo = change mode
|
|
change_mode();
|
|
}
|
|
mode_held = 0;
|
|
mode_press_counter = 0;
|
|
key_pressed_with_mode = 0;
|
|
}
|
|
|
|
// Handle keypad input
|
|
if(stable == 3 && key != 0xFF) {
|
|
// Key pressed and stable
|
|
|
|
// Check if this is an operator key (A-E)
|
|
is_operator_key = (key >= 10 && key <= 14);
|
|
|
|
// In HEX mode, operators require MODE button
|
|
// In other modes, operator keys work directly
|
|
operator_mode = 0;
|
|
if(current_base == MODE_HEX) {
|
|
operator_mode = (mode_held && is_operator_key);
|
|
} else {
|
|
operator_mode = is_operator_key;
|
|
}
|
|
|
|
if(operator_mode) {
|
|
// OPERATOR INPUT
|
|
key_pressed_with_mode = 1;
|
|
|
|
if(key == 10) { // A = Addition
|
|
stored_num = input_num;
|
|
operation = OP_ADD;
|
|
input_num = 0;
|
|
result_displayed = 0;
|
|
display_status();
|
|
} else if(key == 11) { // B = Subtraction
|
|
stored_num = input_num;
|
|
operation = OP_SUB;
|
|
input_num = 0;
|
|
result_displayed = 0;
|
|
display_status();
|
|
} else if(key == 12) { // C = Multiplication
|
|
stored_num = input_num;
|
|
operation = OP_MUL;
|
|
input_num = 0;
|
|
result_displayed = 0;
|
|
display_status();
|
|
} else if(key == 13) { // D = Equals
|
|
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;
|
|
|
|
input_num = result;
|
|
operation = OP_NONE;
|
|
result_displayed = 1;
|
|
display_status();
|
|
} else if(key == 14) { // E = Clear
|
|
input_num = 0;
|
|
stored_num = 0;
|
|
operation = OP_NONE;
|
|
result = 0;
|
|
result_displayed = 0;
|
|
display_status();
|
|
}
|
|
|
|
// Reset debounce after operator is processed
|
|
stable = 0;
|
|
last_key = 0xFF;
|
|
delay(500000); // Delay to let user release the key
|
|
|
|
} else {
|
|
// DIGIT INPUT MODE
|
|
if(is_valid_digit(key)) {
|
|
result_displayed = 0;
|
|
input_num = input_num * current_base + key;
|
|
if(input_num > 32767)
|
|
input_num = input_num % 32768;
|
|
if(input_num < -32768)
|
|
input_num = -32768;
|
|
display_status();
|
|
|
|
stable = 5; // Prevent repeated triggers
|
|
}
|
|
}
|
|
}
|
|
|
|
// ===== STATE MACHINE DISPLAY ON 7-SEGMENT =====
|
|
|
|
if(operation == OP_NONE && result_displayed == 0) {
|
|
seg_pattern = 0x06; // Display '1'
|
|
} else if(operation != OP_NONE) {
|
|
seg_pattern = 0x5B | 0x80; // Display '2' with DP
|
|
} else if(result_displayed == 1) {
|
|
seg_pattern = 0x4F | 0x80; // Display '3' with DP
|
|
} else {
|
|
seg_pattern = 0x3F; // Display '0'
|
|
}
|
|
|
|
// Update the 7-segment display
|
|
LPC_GPIO0->FIOCLR = (0xFF << SEG_SHIFT);
|
|
LPC_GPIO0->FIOSET = (seg_pattern << SEG_SHIFT);
|
|
LPC_GPIO1->FIOSET = DIGIT_EN;
|
|
|
|
delay(3000);
|
|
}
|
|
|
|
return 0;
|
|
}
|